From b611ff52cf4916062560ba0da0e9183bad519a6b Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Sun, 9 Sep 2018 18:31:41 +0200
Subject: [PATCH 01/39] Support URL patterns for content.autoplay

---
 doc/changelog.asciidoc            | 1 +
 doc/help/settings.asciidoc        | 4 +++-
 qutebrowser/config/configdata.yml | 4 +++-
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/doc/changelog.asciidoc b/doc/changelog.asciidoc
index 1fc848a1e..7b98ea71d 100644
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
@@ -48,6 +48,7 @@ Changed
 - Various performance improvements when many tabs are opened.
 - Regenerating completion history now shows a progress dialog.
 - Make qute:// pages work properly on Qt 5.11.2
+- The `content.autoplay` setting now supports URL patterns on Qt >= 5.11.
 
 Removed
 ~~~~~~~
diff --git a/doc/help/settings.asciidoc b/doc/help/settings.asciidoc
index 5e302adfa..d49c61ac5 100644
--- a/doc/help/settings.asciidoc
+++ b/doc/help/settings.asciidoc
@@ -1488,7 +1488,9 @@ Default:
 [[content.autoplay]]
 === content.autoplay
 Automatically start playing `<video>` elements.
-Note this option needs a restart with QtWebEngine on Qt < 5.11.
+Note: On Qt < 5.11, this option needs a restart and does not support URL patterns.
+
+This setting supports URL patterns.
 
 Type: <<types,Bool>>
 
diff --git a/qutebrowser/config/configdata.yml b/qutebrowser/config/configdata.yml
index 6d75ae41c..676b48026 100644
--- a/qutebrowser/config/configdata.yml
+++ b/qutebrowser/config/configdata.yml
@@ -220,10 +220,12 @@ content.autoplay:
   backend:
     QtWebEngine: Qt 5.10
     QtWebKit: false
+  supports_pattern: true
   desc: >-
     Automatically start playing `<video>` elements.
 
-    Note this option needs a restart with QtWebEngine on Qt < 5.11.
+    Note: On Qt < 5.11, this option needs a restart and does not support URL
+    patterns.
 
 content.cache.size:
   default: null

From dc82ac3eb2c883728ff447b6f70a3197b328d9ae Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 5 Sep 2018 22:51:28 +0200
Subject: [PATCH 02/39] Move qute_pdfjs to qutescheme.py

---
 qutebrowser/browser/qutescheme.py             | 19 ++++++
 .../webkit/network/webkitqutescheme.py        | 21 +------
 tests/unit/browser/test_qutescheme.py         | 37 ++++++++++-
 .../webkit/network/test_webkitqutescheme.py   | 63 -------------------
 4 files changed, 56 insertions(+), 84 deletions(-)
 delete mode 100644 tests/unit/browser/webkit/network/test_webkitqutescheme.py

diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 35bd2a436..1679df877 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -44,6 +44,7 @@ import pkg_resources
 from PyQt5.QtCore import QUrlQuery, QUrl
 
 import qutebrowser
+from qutebrowser.browser import pdfjs
 from qutebrowser.config import config, configdata, configexc, configdiff
 from qutebrowser.utils import (version, utils, jinja, log, message, docutils,
                                objreg, urlutils)
@@ -531,3 +532,21 @@ def qute_pastebin_version(_url):
     """Handler that pastebins the version string."""
     version.pastebin_version()
     return 'text/plain', b'Paste called.'
+
+
+@add_handler('pdfjs')
+def qute_pdfjs(url):
+    """Handler for qute://pdfjs. Return the pdf.js viewer."""
+    try:
+        data = pdfjs.get_pdfjs_res(url.path())
+    except pdfjs.PDFJSNotFound as e:
+        # Logging as the error might get lost otherwise since we're not showing
+        # the error page if a single asset is missing. This way we don't lose
+        # information, as the failed pdfjs requests are still in the log.
+        log.misc.warning(
+            "pdfjs resource requested but not found: {}".format(e.path))
+        raise NotFoundError("Can't find pdfjs resource '{}'".format(e.path))
+    else:
+        mimetype, _encoding = mimetypes.guess_type(url.fileName())
+        assert mimetype is not None, url
+        return mimetype, data
diff --git a/qutebrowser/browser/webkit/network/webkitqutescheme.py b/qutebrowser/browser/webkit/network/webkitqutescheme.py
index 1c3bfff82..18473addf 100644
--- a/qutebrowser/browser/webkit/network/webkitqutescheme.py
+++ b/qutebrowser/browser/webkit/network/webkitqutescheme.py
@@ -24,7 +24,7 @@ import mimetypes
 from PyQt5.QtCore import QUrl
 from PyQt5.QtNetwork import QNetworkReply, QNetworkAccessManager
 
-from qutebrowser.browser import pdfjs, qutescheme
+from qutebrowser.browser import qutescheme
 from qutebrowser.browser.webkit.network import networkreply
 from qutebrowser.utils import log, usertypes, qtutils
 
@@ -81,22 +81,3 @@ def handler(request, operation, current_url):
         return networkreply.RedirectNetworkReply(e.url)
 
     return networkreply.FixedDataNetworkReply(request, data, mimetype)
-
-
-@qutescheme.add_handler('pdfjs', backend=usertypes.Backend.QtWebKit)
-def qute_pdfjs(url):
-    """Handler for qute://pdfjs. Return the pdf.js viewer."""
-    try:
-        data = pdfjs.get_pdfjs_res(url.path())
-    except pdfjs.PDFJSNotFound as e:
-        # Logging as the error might get lost otherwise since we're not showing
-        # the error page if a single asset is missing. This way we don't lose
-        # information, as the failed pdfjs requests are still in the log.
-        log.misc.warning(
-            "pdfjs resource requested but not found: {}".format(e.path))
-        raise qutescheme.NotFoundError("Can't find pdfjs resource '{}'".format(
-            e.path))
-    else:
-        mimetype, _encoding = mimetypes.guess_type(url.fileName())
-        assert mimetype is not None, url
-        return mimetype, data
diff --git a/tests/unit/browser/test_qutescheme.py b/tests/unit/browser/test_qutescheme.py
index fbe9287ac..9a21efc50 100644
--- a/tests/unit/browser/test_qutescheme.py
+++ b/tests/unit/browser/test_qutescheme.py
@@ -20,11 +20,12 @@
 import json
 import os
 import time
+import logging
 
 from PyQt5.QtCore import QUrl
 import pytest
 
-from qutebrowser.browser import qutescheme
+from qutebrowser.browser import qutescheme, pdfjs
 
 
 class TestJavascriptHandler:
@@ -169,3 +170,37 @@ class TestHelpHandler:
         mimetype, data = qutescheme.qute_help(QUrl('qute://help/foo.bin'))
         assert mimetype == 'application/octet-stream'
         assert data == b'\xff'
+
+
+class TestPDFJSHandler:
+
+    """Test the qute://pdfjs endpoint."""
+
+    @pytest.fixture(autouse=True)
+    def fake_pdfjs(self, monkeypatch):
+        def get_pdfjs_res(path):
+            if path == '/existing/file.html':
+                return b'foobar'
+            raise pdfjs.PDFJSNotFound(path)
+
+        monkeypatch.setattr(pdfjs, 'get_pdfjs_res', get_pdfjs_res)
+
+    @pytest.fixture(autouse=True)
+    def patch_backend(self, monkeypatch):
+        monkeypatch.setattr(qutescheme.objects, 'backend',
+                            usertypes.Backend.QtWebKit)
+
+    def test_existing_resource(self):
+        """Test with a resource that exists."""
+        _mimetype, data = qutescheme.data_for_url(
+            QUrl('qute://pdfjs/existing/file.html'))
+        assert data == b'foobar'
+
+    def test_nonexisting_resource(self, caplog):
+        """Test with a resource that does not exist."""
+        with caplog.at_level(logging.WARNING, 'misc'):
+            with pytest.raises(qutescheme.NotFoundError):
+                qutescheme.data_for_url(QUrl('qute://pdfjs/no/file.html'))
+        assert len(caplog.records) == 1
+        assert (caplog.records[0].message ==
+                'pdfjs resource requested but not found: /no/file.html')
diff --git a/tests/unit/browser/webkit/network/test_webkitqutescheme.py b/tests/unit/browser/webkit/network/test_webkitqutescheme.py
deleted file mode 100644
index 05190d230..000000000
--- a/tests/unit/browser/webkit/network/test_webkitqutescheme.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
-
-# Copyright 2016-2018 Daniel Schadt
-# Copyright 2016-2018 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
-#
-# This file is part of qutebrowser.
-#
-# qutebrowser is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# qutebrowser is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
-
-import logging
-
-import pytest
-from PyQt5.QtCore import QUrl
-
-from qutebrowser.utils import usertypes
-from qutebrowser.browser import pdfjs, qutescheme
-# pylint: disable=unused-import
-from qutebrowser.browser.webkit.network import webkitqutescheme
-# pylint: enable=unused-import
-
-
-class TestPDFJSHandler:
-    """Test the qute://pdfjs endpoint."""
-
-    @pytest.fixture(autouse=True)
-    def fake_pdfjs(self, monkeypatch):
-        def get_pdfjs_res(path):
-            if path == '/existing/file.html':
-                return b'foobar'
-            raise pdfjs.PDFJSNotFound(path)
-
-        monkeypatch.setattr(pdfjs, 'get_pdfjs_res', get_pdfjs_res)
-
-    @pytest.fixture(autouse=True)
-    def patch_backend(self, monkeypatch):
-        monkeypatch.setattr(qutescheme.objects, 'backend',
-                            usertypes.Backend.QtWebKit)
-
-    def test_existing_resource(self):
-        """Test with a resource that exists."""
-        _mimetype, data = qutescheme.data_for_url(
-            QUrl('qute://pdfjs/existing/file.html'))
-        assert data == b'foobar'
-
-    def test_nonexisting_resource(self, caplog):
-        """Test with a resource that does not exist."""
-        with caplog.at_level(logging.WARNING, 'misc'):
-            with pytest.raises(qutescheme.NotFoundError):
-                qutescheme.data_for_url(QUrl('qute://pdfjs/no/file.html'))
-        assert len(caplog.records) == 1
-        assert (caplog.records[0].message ==
-                'pdfjs resource requested but not found: /no/file.html')

From 36b2f5e63f21ba76b7e64629625cc819dc7067a6 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 5 Sep 2018 22:51:58 +0200
Subject: [PATCH 03/39] Remove qute:// backend= argument

---
 qutebrowser/browser/qutescheme.py | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 1679df877..edf9f02bd 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -114,12 +114,10 @@ class add_handler:  # noqa: N801,N806 pylint: disable=invalid-name
 
     Attributes:
         _name: The 'foo' part of qute://foo
-        backend: Limit which backends the handler can run with.
     """
 
-    def __init__(self, name, backend=None):
+    def __init__(self, name):
         self._name = name
-        self._backend = backend
         self._function = None
 
     def __call__(self, function):
@@ -129,19 +127,7 @@ class add_handler:  # noqa: N801,N806 pylint: disable=invalid-name
 
     def wrapper(self, *args, **kwargs):
         """Call the underlying function."""
-        if self._backend is not None and objects.backend != self._backend:
-            return self.wrong_backend_handler(*args, **kwargs)
-        else:
-            return self._function(*args, **kwargs)
-
-    def wrong_backend_handler(self, url):
-        """Show an error page about using the invalid backend."""
-        src = jinja.render('error.html',
-                           title="Error while opening qute://url",
-                           url=url.toDisplayString(),
-                           error='{} is not available with this '
-                                 'backend'.format(url.toDisplayString()))
-        return 'text/html', src
+        return self._function(*args, **kwargs)
 
 
 def data_for_url(url):

From 8f1690eff73f23535a182294560948988a0650da Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 5 Sep 2018 23:18:04 +0200
Subject: [PATCH 04/39] Move pdfjs error page to pdfjs.py

---
 qutebrowser/browser/pdfjs.py          | 6 +++++-
 qutebrowser/browser/webkit/webpage.py | 7 +------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 5ce3d866e..379b30240 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -24,7 +24,7 @@ import os
 
 from PyQt5.QtCore import QUrl
 
-from qutebrowser.utils import utils, javascript
+from qutebrowser.utils import utils, javascript, jinja
 
 
 class PDFJSNotFound(Exception):
@@ -49,6 +49,10 @@ def generate_pdfjs_page(url):
     Args:
         url: The url of the pdf as QUrl.
     """
+    if not is_available():
+        return jinja.render('no_pdfjs.html',
+                            url=url.toDisplayString(),
+                            title="PDF.js not found")
     viewer = get_pdfjs_res('web/viewer.html').decode('utf-8')
     script = _generate_pdfjs_script(url)
     html_page = viewer.replace('</body>',
diff --git a/qutebrowser/browser/webkit/webpage.py b/qutebrowser/browser/webkit/webpage.py
index 4e0701329..90e56ec56 100644
--- a/qutebrowser/browser/webkit/webpage.py
+++ b/qutebrowser/browser/webkit/webpage.py
@@ -208,12 +208,7 @@ class BrowserPage(QWebPage):
 
     def _show_pdfjs(self, reply):
         """Show the reply with pdfjs."""
-        try:
-            page = pdfjs.generate_pdfjs_page(reply.url())
-        except pdfjs.PDFJSNotFound:
-            page = jinja.render('no_pdfjs.html',
-                                url=reply.url().toDisplayString(),
-                                title="PDF.js not found")
+        page = pdfjs.generate_pdfjs_page(reply.url())
         self.mainFrame().setContent(page.encode('utf-8'), 'text/html',
                                     reply.url())
         reply.deleteLater()

From df67c254f8dff857ad61b8f3f8f8b51ccdabfc44 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:11:28 +0200
Subject: [PATCH 05/39] Initial attempt at getting PDF.js to work with separate
 downloads

---
 qutebrowser/browser/downloads.py      | 55 +++++++++++++++++++++++----
 qutebrowser/browser/pdfjs.py          | 17 ++++++++-
 qutebrowser/browser/qutescheme.py     |  8 +++-
 qutebrowser/browser/webkit/webpage.py |  9 ++---
 4 files changed, 75 insertions(+), 14 deletions(-)

diff --git a/qutebrowser/browser/downloads.py b/qutebrowser/browser/downloads.py
index 854fd1ca5..a2917e4f0 100644
--- a/qutebrowser/browser/downloads.py
+++ b/qutebrowser/browser/downloads.py
@@ -32,10 +32,11 @@ import enum
 from PyQt5.QtCore import (pyqtSlot, pyqtSignal, Qt, QObject, QModelIndex,
                           QTimer, QAbstractListModel, QUrl)
 
+from qutebrowser.browser import pdfjs
 from qutebrowser.commands import cmdexc, cmdutils
 from qutebrowser.config import config
 from qutebrowser.utils import (usertypes, standarddir, utils, message, log,
-                               qtutils)
+                               qtutils, objreg)
 from qutebrowser.qt import sip
 
 
@@ -224,9 +225,6 @@ class _DownloadTarget:
 
     """Abstract base class for different download targets."""
 
-    def __init__(self):
-        raise NotImplementedError
-
     def suggested_filename(self):
         """Get the suggested filename for this download target."""
         raise NotImplementedError
@@ -300,6 +298,17 @@ class OpenFileDownloadTarget(_DownloadTarget):
         return 'temporary file'
 
 
+class PDFJSDownloadTarget(_DownloadTarget):
+
+    """Open the download via PDF.js."""
+
+    def suggested_filename(self):
+        raise NoFilenameError
+
+    def __str__(self):
+        return 'temporary PDF.js file'
+
+
 class DownloadItemStats(QObject):
 
     """Statistics (bytes done, total bytes, time, etc.) about a download.
@@ -405,6 +414,8 @@ class AbstractDownloadItem(QObject):
                arg: The error message as string.
         remove_requested: Emitted when the removal of this download was
                           requested.
+        pdfjs_requested: Emitted when PDF.js should be opened with the given
+                         filename.
     """
 
     data_changed = pyqtSignal()
@@ -412,6 +423,7 @@ class AbstractDownloadItem(QObject):
     error = pyqtSignal(str)
     cancelled = pyqtSignal()
     remove_requested = pyqtSignal()
+    pdfjs_requested = pyqtSignal(str)
 
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -730,6 +742,19 @@ class AbstractDownloadItem(QObject):
             return
         self.open_file(cmdline)
 
+    def _pdfjs_if_successful(self):
+        """Open the file via PDF.js if downloading was successful."""
+        if not self.successful:
+            log.downloads.debug("{} finished but not successful, not opening!"
+                                .format(self))
+            return
+
+        filename = self._get_open_filename()
+        if filename is None:  # pragma: no cover
+            log.downloads.error("No filename to open the download!")
+            return
+        self.pdfjs_requested.emit(filename)
+
     def set_target(self, target):
         """Set the target for a given download.
 
@@ -741,7 +766,7 @@ class AbstractDownloadItem(QObject):
         elif isinstance(target, FileDownloadTarget):
             self._set_filename(
                 target.filename, force_overwrite=target.force_overwrite)
-        elif isinstance(target, OpenFileDownloadTarget):
+        elif isinstance(target, (OpenFileDownloadTarget, PDFJSDownloadTarget)):
             try:
                 fobj = temp_download_manager.get_tmpfile(self.basename)
             except OSError as exc:
@@ -749,8 +774,15 @@ class AbstractDownloadItem(QObject):
                 message.error(msg)
                 self.cancel()
                 return
-            self.finished.connect(
-                functools.partial(self._open_if_successful, target.cmdline))
+
+            if isinstance(target, OpenFileDownloadTarget):
+                self.finished.connect(
+                    functools.partial(self._open_if_successful, target.cmdline))
+            elif isinstance(target, PDFJSDownloadTarget):
+                self.finished.connect(self._pdfjs_if_successful)
+            else:
+                assert False, target
+
             self._set_tempfile(fobj)
         else:  # pragma: no cover
             raise ValueError("Unsupported download target: {}".format(target))
@@ -797,6 +829,13 @@ class AbstractDownloadManager(QObject):
             dl.stats.update_speed()
         self.data_changed.emit(-1)
 
+    @pyqtSlot(str)
+    def _on_pdfjs_requested(self, filename):
+        """Open PDF.js when a download requests it."""
+        tabbed_browser = objreg.get('tabbed-browser', scope='window',
+                                    window='last-focused')
+        tabbed_browser.tabopen(pdfjs.get_main_url(filename))
+
     def _init_item(self, download, auto_remove, suggested_filename):
         """Initialize a newly created DownloadItem."""
         download.cancelled.connect(download.remove)
@@ -813,6 +852,8 @@ class AbstractDownloadManager(QObject):
         download.data_changed.connect(
             functools.partial(self._on_data_changed, download))
         download.error.connect(self._on_error)
+        download.pdfjs_requested.connect(self._on_pdfjs_requested)
+
         download.basename = suggested_filename
         idx = len(self.downloads)
         download.index = idx + 1  # "Human readable" index
diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 379b30240..49c65e2ee 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -22,9 +22,10 @@
 
 import os
 
-from PyQt5.QtCore import QUrl
+from PyQt5.QtCore import QUrl, QUrlQuery
 
 from qutebrowser.utils import utils, javascript, jinja
+from qutebrowser.config import config
 
 
 class PDFJSNotFound(Exception):
@@ -210,3 +211,17 @@ def is_available():
         return False
     else:
         return True
+
+
+def should_use_pdfjs(mimetype):
+    return (mimetype in ['application/pdf', 'application/x-pdf'] and
+            config.val.content.pdfjs)
+
+
+def get_main_url(filename):
+    """Get the URL to be opened to view a local PDF."""
+    url = QUrl('qute://pdfjs')
+    query = QUrlQuery()
+    query.addQueryItem('file', QUrl.fromLocalFile(filename).toString())
+    url.setQuery(query)
+    return url
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index edf9f02bd..1126a3204 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -523,6 +523,11 @@ def qute_pastebin_version(_url):
 @add_handler('pdfjs')
 def qute_pdfjs(url):
     """Handler for qute://pdfjs. Return the pdf.js viewer."""
+    if url.path() == '/':
+        filepath = QUrlQuery(url).queryItemValue("file")
+        data = pdfjs.generate_pdfjs_page(QUrl.fromLocalFile(filepath))
+        return 'text/html', data
+
     try:
         data = pdfjs.get_pdfjs_res(url.path())
     except pdfjs.PDFJSNotFound as e:
@@ -534,5 +539,6 @@ def qute_pdfjs(url):
         raise NotFoundError("Can't find pdfjs resource '{}'".format(e.path))
     else:
         mimetype, _encoding = mimetypes.guess_type(url.fileName())
-        assert mimetype is not None, url
+        if mimetype is None:
+            mimetype = 'application/octet-stream'
         return mimetype, data
diff --git a/qutebrowser/browser/webkit/webpage.py b/qutebrowser/browser/webkit/webpage.py
index 90e56ec56..c0e3ce57b 100644
--- a/qutebrowser/browser/webkit/webpage.py
+++ b/qutebrowser/browser/webkit/webpage.py
@@ -30,7 +30,7 @@ from PyQt5.QtPrintSupport import QPrintDialog
 from PyQt5.QtWebKitWidgets import QWebPage, QWebFrame
 
 from qutebrowser.config import config
-from qutebrowser.browser import pdfjs, shared
+from qutebrowser.browser import pdfjs, shared, downloads
 from qutebrowser.browser.webkit import http
 from qutebrowser.browser.webkit.network import networkmanager
 from qutebrowser.utils import message, usertypes, log, jinja, objreg
@@ -275,10 +275,9 @@ class BrowserPage(QWebPage):
             else:
                 reply.finished.connect(functools.partial(
                     self.display_content, reply, 'image/jpeg'))
-        elif (mimetype in ['application/pdf', 'application/x-pdf'] and
-              config.val.content.pdfjs):
-            # Use pdf.js to display the page
-            self._show_pdfjs(reply)
+        elif pdfjs.should_use_pdfjs(mimetype):
+            download_manager.fetch(reply,
+                                   target=downloads.PDFJSDownloadTarget())
         else:
             # Unknown mimetype, so download anyways.
             download_manager.fetch(reply,

From 24fb3b0d1b6fc7ff77cc98907cc7067352a787e3 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:15:13 +0200
Subject: [PATCH 06/39] Simplify getting pdfjs main page

---
 qutebrowser/browser/pdfjs.py      | 35 +------------------------------
 qutebrowser/browser/qutescheme.py |  5 -----
 tests/unit/browser/test_pdfjs.py  | 18 ----------------
 3 files changed, 1 insertion(+), 57 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 49c65e2ee..df8697753 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -42,39 +42,6 @@ class PDFJSNotFound(Exception):
         super().__init__(message)
 
 
-def generate_pdfjs_page(url):
-    """Return the html content of a page that displays url with pdfjs.
-
-    Returns a string.
-
-    Args:
-        url: The url of the pdf as QUrl.
-    """
-    if not is_available():
-        return jinja.render('no_pdfjs.html',
-                            url=url.toDisplayString(),
-                            title="PDF.js not found")
-    viewer = get_pdfjs_res('web/viewer.html').decode('utf-8')
-    script = _generate_pdfjs_script(url)
-    html_page = viewer.replace('</body>',
-                               '</body><script>{}</script>'.format(script))
-    return html_page
-
-
-def _generate_pdfjs_script(url):
-    """Generate the script that shows the pdf with pdf.js.
-
-    Args:
-        url: The url of the pdf page as QUrl.
-    """
-    return (
-        'document.addEventListener("DOMContentLoaded", function() {{\n'
-        '  PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;\n'
-        '  (window.PDFView || window.PDFViewerApplication).open("{url}");\n'
-        '}});\n'
-    ).format(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
-
-
 def fix_urls(asset):
     """Take an html page and replace each relative URL with an absolute.
 
@@ -220,7 +187,7 @@ def should_use_pdfjs(mimetype):
 
 def get_main_url(filename):
     """Get the URL to be opened to view a local PDF."""
-    url = QUrl('qute://pdfjs')
+    url = QUrl('qute://pdfjs/web/viewer.html')
     query = QUrlQuery()
     query.addQueryItem('file', QUrl.fromLocalFile(filename).toString())
     url.setQuery(query)
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 1126a3204..ec198bc13 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -523,11 +523,6 @@ def qute_pastebin_version(_url):
 @add_handler('pdfjs')
 def qute_pdfjs(url):
     """Handler for qute://pdfjs. Return the pdf.js viewer."""
-    if url.path() == '/':
-        filepath = QUrlQuery(url).queryItemValue("file")
-        data = pdfjs.generate_pdfjs_page(QUrl.fromLocalFile(filepath))
-        return 'text/html', data
-
     try:
         data = pdfjs.get_pdfjs_res(url.path())
     except pdfjs.PDFJSNotFound as e:
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index a33dae5bf..f5c6bed4c 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -25,24 +25,6 @@ from PyQt5.QtCore import QUrl
 from qutebrowser.browser import pdfjs
 
 
-# Note that we got double protection, once because we use QUrl.FullyEncoded and
-# because we use qutebrowser.utils.javascript.string_escape.  Characters
-# like " are already replaced by QUrl.
-@pytest.mark.parametrize('url, expected', [
-    ('http://foo.bar', "http://foo.bar"),
-    ('http://"', ''),
-    ('\0', '%00'),
-    ('http://foobar/");alert("attack!");',
-     'http://foobar/%22);alert(%22attack!%22);'),
-])
-def test_generate_pdfjs_script(url, expected):
-    expected_open = 'open("{}");'.format(expected)
-    url = QUrl(url)
-    actual = pdfjs._generate_pdfjs_script(url)
-    assert expected_open in actual
-    assert 'PDFView' in actual
-
-
 def test_fix_urls():
     page = textwrap.dedent("""
         <html>

From 8f19820a7ad4370f722db179c819dc0629b0b13f Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:18:09 +0200
Subject: [PATCH 07/39] Remove pdfjs.fix_urls

Now that we use qute://pdfjs to show the viewer, we don't need to rewrite any
URLs.
---
 qutebrowser/browser/pdfjs.py     | 35 +-------------------------------
 tests/unit/browser/test_pdfjs.py | 24 ----------------------
 2 files changed, 1 insertion(+), 58 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index df8697753..60e51e6cd 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -42,33 +42,6 @@ class PDFJSNotFound(Exception):
         super().__init__(message)
 
 
-def fix_urls(asset):
-    """Take an html page and replace each relative URL with an absolute.
-
-    This is specialized for pdf.js files and not a general purpose function.
-
-    Args:
-        asset: js file or html page as string.
-    """
-    new_urls = [
-        ('viewer.css', 'qute://pdfjs/web/viewer.css'),
-        ('compatibility.js', 'qute://pdfjs/web/compatibility.js'),
-        ('locale/locale.properties',
-         'qute://pdfjs/web/locale/locale.properties'),
-        ('l10n.js', 'qute://pdfjs/web/l10n.js'),
-        ('../build/pdf.js', 'qute://pdfjs/build/pdf.js'),
-        ('debugger.js', 'qute://pdfjs/web/debugger.js'),
-        ('viewer.js', 'qute://pdfjs/web/viewer.js'),
-        ('compressed.tracemonkey-pldi-09.pdf', ''),
-        ('./images/', 'qute://pdfjs/web/images/'),
-        ('../build/pdf.worker.js', 'qute://pdfjs/build/pdf.worker.js'),
-        ('../web/cmaps/', 'qute://pdfjs/web/cmaps/'),
-    ]
-    for original, new in new_urls:
-        asset = asset.replace(original, new)
-    return asset
-
-
 SYSTEM_PDFJS_PATHS = [
     # Debian pdf.js-common
     # Arch Linux pdfjs (AUR)
@@ -113,13 +86,7 @@ def get_pdfjs_res_and_path(path):
         except FileNotFoundError:
             raise PDFJSNotFound(path) from None
 
-    try:
-        # Might be script/html or might be binary
-        text_content = content.decode('utf-8')
-    except UnicodeDecodeError:
-        return (content, file_path)
-    text_content = fix_urls(text_content)
-    return (text_content.encode('utf-8'), file_path)
+    return content, file_path
 
 
 def get_pdfjs_res(path):
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index f5c6bed4c..a50859c3e 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -17,35 +17,11 @@
 # You should have received a copy of the GNU General Public License
 # along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
 
-import textwrap
-
 import pytest
-from PyQt5.QtCore import QUrl
 
 from qutebrowser.browser import pdfjs
 
 
-def test_fix_urls():
-    page = textwrap.dedent("""
-        <html>
-        <script src="viewer.js"></script>
-        <link href="viewer.css">
-        <script src="unrelated.js"></script>
-        </html>
-    """).strip()
-
-    expected = textwrap.dedent("""
-        <html>
-        <script src="qute://pdfjs/web/viewer.js"></script>
-        <link href="qute://pdfjs/web/viewer.css">
-        <script src="unrelated.js"></script>
-        </html>
-    """).strip()
-
-    actual = pdfjs.fix_urls(page)
-    assert actual == expected
-
-
 @pytest.mark.parametrize('path, expected', [
     ('web/viewer.js', 'viewer.js'),
     ('build/locale/foo.bar', 'locale/foo.bar'),

From cb0c3134044aff00c79e5150164266a3c72a5268 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:32:11 +0200
Subject: [PATCH 08/39] Add qute://pdfjs/file to get files

Cross-origin requests aren't supported for qute:// URLs, and qute:// can't
access file://, so we need to get the files that way.
---
 qutebrowser/browser/pdfjs.py      |  8 +++++++-
 qutebrowser/browser/qutescheme.py | 10 ++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 60e51e6cd..a51490d0a 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -155,7 +155,13 @@ def should_use_pdfjs(mimetype):
 def get_main_url(filename):
     """Get the URL to be opened to view a local PDF."""
     url = QUrl('qute://pdfjs/web/viewer.html')
+
+    file_url = QUrl('qute://pdfjs/file')
+    file_url_query = QUrlQuery()
+    file_url_query.addQueryItem('filename', filename)
+    file_url.setQuery(file_url_query)
+
     query = QUrlQuery()
-    query.addQueryItem('file', QUrl.fromLocalFile(filename).toString())
+    query.addQueryItem('file', file_url.toString())
     url.setQuery(query)
     return url
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index ec198bc13..00c5d44bd 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -523,6 +523,16 @@ def qute_pastebin_version(_url):
 @add_handler('pdfjs')
 def qute_pdfjs(url):
     """Handler for qute://pdfjs. Return the pdf.js viewer."""
+    # FIXME be more strict about allowed files here
+    if url.path() == '/file':
+        filename = QUrlQuery(url).queryItemValue('filename')
+        with open(filename, 'rb') as f:
+            data = f.read()
+        mimetype, _encoding = mimetypes.guess_type(filename)
+        if mimetype is None:
+            mimetype = 'application/octet-stream'
+        return mimetype, data
+
     try:
         data = pdfjs.get_pdfjs_res(url.path())
     except pdfjs.PDFJSNotFound as e:

From a0b4f09f026f1ee303b22bdb2fbaa2e4a6ef74ad Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:35:36 +0200
Subject: [PATCH 09/39] Initial PDF.js support for QtWebEngine

---
 qutebrowser/browser/webengine/webenginedownloads.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/browser/webengine/webenginedownloads.py b/qutebrowser/browser/webengine/webenginedownloads.py
index 68e151959..4b48e7be5 100644
--- a/qutebrowser/browser/webengine/webenginedownloads.py
+++ b/qutebrowser/browser/webengine/webenginedownloads.py
@@ -27,7 +27,7 @@ import functools
 from PyQt5.QtCore import pyqtSlot, Qt
 from PyQt5.QtWebEngineWidgets import QWebEngineDownloadItem
 
-from qutebrowser.browser import downloads
+from qutebrowser.browser import downloads, pdfjs
 from qutebrowser.utils import debug, usertypes, message, log, qtutils
 
 
@@ -221,6 +221,10 @@ class DownloadManager(downloads.AbstractDownloadManager):
             download.set_target(self._mhtml_target)
             self._mhtml_target = None
             return
+        if pdfjs.should_use_pdfjs(qt_item.mimeType()):
+            download.set_target(downloads.PDFJSDownloadTarget())
+            return
+
 
         filename = downloads.immediate_download_path()
         if filename is not None:

From 7206dde19cda29b17f7bca860080435b9b2256a0 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:52:52 +0200
Subject: [PATCH 10/39] Revert "Simplify getting pdfjs main page"

This reverts commit 9c731bde85627308fdde4730b0181a014096cb47.

We need to set some PDF.js options, so we can't just use the default viewer
with ?file=...
---
 qutebrowser/browser/pdfjs.py      | 62 ++++++++++++++++++++++++++++++-
 qutebrowser/browser/qutescheme.py |  5 +++
 tests/unit/browser/test_pdfjs.py  | 39 +++++++++++++++++++
 3 files changed, 105 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index a51490d0a..fe38121d9 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -42,6 +42,66 @@ class PDFJSNotFound(Exception):
         super().__init__(message)
 
 
+def generate_pdfjs_page(url):
+    """Return the html content of a page that displays url with pdfjs.
+
+    Returns a string.
+
+    Args:
+        url: The url of the pdf as QUrl.
+    """
+    if not is_available():
+        return jinja.render('no_pdfjs.html',
+                            url=url.toDisplayString(),
+                            title="PDF.js not found")
+    viewer = get_pdfjs_res('web/viewer.html').decode('utf-8')
+    script = _generate_pdfjs_script(url)
+    html_page = viewer.replace('</body>',
+                               '</body><script>{}</script>'.format(script))
+    return html_page
+
+
+def _generate_pdfjs_script(url):
+    """Generate the script that shows the pdf with pdf.js.
+
+    Args:
+        url: The url of the pdf page as QUrl.
+    """
+    return (
+        'document.addEventListener("DOMContentLoaded", function() {{\n'
+        '  PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;\n'
+        '  (window.PDFView || window.PDFViewerApplication).open("{url}");\n'
+        '}});\n'
+    ).format(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
+
+
+def fix_urls(asset):
+    """Take an html page and replace each relative URL with an absolute.
+
+    This is specialized for pdf.js files and not a general purpose function.
+
+    Args:
+        asset: js file or html page as string.
+    """
+    new_urls = [
+        ('viewer.css', 'qute://pdfjs/web/viewer.css'),
+        ('compatibility.js', 'qute://pdfjs/web/compatibility.js'),
+        ('locale/locale.properties',
+         'qute://pdfjs/web/locale/locale.properties'),
+        ('l10n.js', 'qute://pdfjs/web/l10n.js'),
+        ('../build/pdf.js', 'qute://pdfjs/build/pdf.js'),
+        ('debugger.js', 'qute://pdfjs/web/debugger.js'),
+        ('viewer.js', 'qute://pdfjs/web/viewer.js'),
+        ('compressed.tracemonkey-pldi-09.pdf', ''),
+        ('./images/', 'qute://pdfjs/web/images/'),
+        ('../build/pdf.worker.js', 'qute://pdfjs/build/pdf.worker.js'),
+        ('../web/cmaps/', 'qute://pdfjs/web/cmaps/'),
+    ]
+    for original, new in new_urls:
+        asset = asset.replace(original, new)
+    return asset
+
+
 SYSTEM_PDFJS_PATHS = [
     # Debian pdf.js-common
     # Arch Linux pdfjs (AUR)
@@ -154,7 +214,7 @@ def should_use_pdfjs(mimetype):
 
 def get_main_url(filename):
     """Get the URL to be opened to view a local PDF."""
-    url = QUrl('qute://pdfjs/web/viewer.html')
+    url = QUrl('qute://pdfjs/')
 
     file_url = QUrl('qute://pdfjs/file')
     file_url_query = QUrlQuery()
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 00c5d44bd..388c02494 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -533,6 +533,11 @@ def qute_pdfjs(url):
             mimetype = 'application/octet-stream'
         return mimetype, data
 
+    if url.path() == '/':
+        filepath = QUrlQuery(url).queryItemValue("file")
+        data = pdfjs.generate_pdfjs_page(QUrl.fromLocalFile(filepath))
+        return 'text/html', data
+
     try:
         data = pdfjs.get_pdfjs_res(url.path())
     except pdfjs.PDFJSNotFound as e:
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index a50859c3e..20d91ab9c 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -22,6 +22,45 @@ import pytest
 from qutebrowser.browser import pdfjs
 
 
+# Note that we got double protection, once because we use QUrl.FullyEncoded and
+# because we use qutebrowser.utils.javascript.string_escape.  Characters
+# like " are already replaced by QUrl.
+@pytest.mark.parametrize('url, expected', [
+    ('http://foo.bar', "http://foo.bar"),
+    ('http://"', ''),
+    ('\0', '%00'),
+    ('http://foobar/");alert("attack!");',
+     'http://foobar/%22);alert(%22attack!%22);'),
+])
+def test_generate_pdfjs_script(url, expected):
+    expected_open = 'open("{}");'.format(expected)
+    url = QUrl(url)
+    actual = pdfjs._generate_pdfjs_script(url)
+    assert expected_open in actual
+    assert 'PDFView' in actual
+
+
+def test_fix_urls():
+    page = textwrap.dedent("""
+        <html>
+        <script src="viewer.js"></script>
+        <link href="viewer.css">
+        <script src="unrelated.js"></script>
+        </html>
+    """).strip()
+
+    expected = textwrap.dedent("""
+        <html>
+        <script src="qute://pdfjs/web/viewer.js"></script>
+        <link href="qute://pdfjs/web/viewer.css">
+        <script src="unrelated.js"></script>
+        </html>
+    """).strip()
+
+    actual = pdfjs.fix_urls(page)
+    assert actual == expected
+
+
 @pytest.mark.parametrize('path, expected', [
     ('web/viewer.js', 'viewer.js'),
     ('build/locale/foo.bar', 'locale/foo.bar'),

From bbcb87e434d547cf8b801d76955ee93af4c5546c Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 00:57:14 +0200
Subject: [PATCH 11/39] Get PDF.js to work

We need to use the /web/viewer.html path so relative references are correct.
---
 qutebrowser/browser/pdfjs.py      | 2 +-
 qutebrowser/browser/qutescheme.py | 2 +-
 tests/unit/browser/test_pdfjs.py  | 3 +++
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index fe38121d9..79ec69ac8 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -214,7 +214,7 @@ def should_use_pdfjs(mimetype):
 
 def get_main_url(filename):
     """Get the URL to be opened to view a local PDF."""
-    url = QUrl('qute://pdfjs/')
+    url = QUrl('qute://pdfjs/web/viewer.html')
 
     file_url = QUrl('qute://pdfjs/file')
     file_url_query = QUrlQuery()
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 388c02494..135089d11 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -533,7 +533,7 @@ def qute_pdfjs(url):
             mimetype = 'application/octet-stream'
         return mimetype, data
 
-    if url.path() == '/':
+    if url.path() == '/web/viewer.html':
         filepath = QUrlQuery(url).queryItemValue("file")
         data = pdfjs.generate_pdfjs_page(QUrl.fromLocalFile(filepath))
         return 'text/html', data
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index 20d91ab9c..a33dae5bf 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -17,7 +17,10 @@
 # You should have received a copy of the GNU General Public License
 # along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
 
+import textwrap
+
 import pytest
+from PyQt5.QtCore import QUrl
 
 from qutebrowser.browser import pdfjs
 

From c40ddf37b70e7cf2cdacec0cdb0e97558893bbcc Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 19:40:43 +0200
Subject: [PATCH 12/39] Set disableCreateObjectURL for PDF.js

We can't use blob URLs or we'll get a renderer crash:
https://bugreports.qt.io/browse/QTBUG-70420

Thankfully, we can tell PDF.js to use data: URLs instead.
---
 qutebrowser/browser/pdfjs.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 79ec69ac8..e36824223 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -69,6 +69,7 @@ def _generate_pdfjs_script(url):
     """
     return (
         'document.addEventListener("DOMContentLoaded", function() {{\n'
+        '  PDFJS.disableCreateObjectURL = true;\n'
         '  PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;\n'
         '  (window.PDFView || window.PDFViewerApplication).open("{url}");\n'
         '}});\n'

From 3ad7ae2a2c2749a0a047ca108ebedb729f778966 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 21:39:04 +0200
Subject: [PATCH 13/39] Remove fix_urls which isn't needed anymore

With qute://pdfjs/web/viewer.html we can use relative URLs
---
 qutebrowser/browser/pdfjs.py     | 27 ---------------------------
 tests/unit/browser/test_pdfjs.py | 21 ---------------------
 2 files changed, 48 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index e36824223..2e6cb5de2 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -76,33 +76,6 @@ def _generate_pdfjs_script(url):
     ).format(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
 
 
-def fix_urls(asset):
-    """Take an html page and replace each relative URL with an absolute.
-
-    This is specialized for pdf.js files and not a general purpose function.
-
-    Args:
-        asset: js file or html page as string.
-    """
-    new_urls = [
-        ('viewer.css', 'qute://pdfjs/web/viewer.css'),
-        ('compatibility.js', 'qute://pdfjs/web/compatibility.js'),
-        ('locale/locale.properties',
-         'qute://pdfjs/web/locale/locale.properties'),
-        ('l10n.js', 'qute://pdfjs/web/l10n.js'),
-        ('../build/pdf.js', 'qute://pdfjs/build/pdf.js'),
-        ('debugger.js', 'qute://pdfjs/web/debugger.js'),
-        ('viewer.js', 'qute://pdfjs/web/viewer.js'),
-        ('compressed.tracemonkey-pldi-09.pdf', ''),
-        ('./images/', 'qute://pdfjs/web/images/'),
-        ('../build/pdf.worker.js', 'qute://pdfjs/build/pdf.worker.js'),
-        ('../web/cmaps/', 'qute://pdfjs/web/cmaps/'),
-    ]
-    for original, new in new_urls:
-        asset = asset.replace(original, new)
-    return asset
-
-
 SYSTEM_PDFJS_PATHS = [
     # Debian pdf.js-common
     # Arch Linux pdfjs (AUR)
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index a33dae5bf..594e69df6 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -43,27 +43,6 @@ def test_generate_pdfjs_script(url, expected):
     assert 'PDFView' in actual
 
 
-def test_fix_urls():
-    page = textwrap.dedent("""
-        <html>
-        <script src="viewer.js"></script>
-        <link href="viewer.css">
-        <script src="unrelated.js"></script>
-        </html>
-    """).strip()
-
-    expected = textwrap.dedent("""
-        <html>
-        <script src="qute://pdfjs/web/viewer.js"></script>
-        <link href="qute://pdfjs/web/viewer.css">
-        <script src="unrelated.js"></script>
-        </html>
-    """).strip()
-
-    actual = pdfjs.fix_urls(page)
-    assert actual == expected
-
-
 @pytest.mark.parametrize('path, expected', [
     ('web/viewer.js', 'viewer.js'),
     ('build/locale/foo.bar', 'locale/foo.bar'),

From 6665a1348e0c8031ffacb3dd10f96b7462b4e3b0 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 21:47:30 +0200
Subject: [PATCH 14/39] Use jinja to get PDF.js script

---
 qutebrowser/browser/pdfjs.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 2e6cb5de2..acb0fb467 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -67,13 +67,13 @@ def _generate_pdfjs_script(url):
     Args:
         url: The url of the pdf page as QUrl.
     """
-    return (
-        'document.addEventListener("DOMContentLoaded", function() {{\n'
-        '  PDFJS.disableCreateObjectURL = true;\n'
-        '  PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;\n'
-        '  (window.PDFView || window.PDFViewerApplication).open("{url}");\n'
-        '}});\n'
-    ).format(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
+    return jinja.js_environment.from_string("""
+        document.addEventListener("DOMContentLoaded", function() {
+          PDFJS.disableCreateObjectURL = true;
+          PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;
+          (window.PDFView || window.PDFViewerApplication).open("{{ url }}");
+        });
+    """).render(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
 
 
 SYSTEM_PDFJS_PATHS = [

From 2dccde8f4b67855de5d2620baa6a75cc1b5f8bd6 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 21:57:18 +0200
Subject: [PATCH 15/39] Only set PDFJS.disableCreateObjectURL when necessary

See #4198
---
 qutebrowser/browser/pdfjs.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index acb0fb467..8fe628a02 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -24,7 +24,8 @@ import os
 
 from PyQt5.QtCore import QUrl, QUrlQuery
 
-from qutebrowser.utils import utils, javascript, jinja
+from qutebrowser.utils import utils, javascript, jinja, qtutils, usertypes
+from qutebrowser.misc import objects
 from qutebrowser.config import config
 
 
@@ -69,11 +70,18 @@ def _generate_pdfjs_script(url):
     """
     return jinja.js_environment.from_string("""
         document.addEventListener("DOMContentLoaded", function() {
+          {% if disable_create_object_url %}
           PDFJS.disableCreateObjectURL = true;
+          {% endif %}
           PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;
           (window.PDFView || window.PDFViewerApplication).open("{{ url }}");
         });
-    """).render(url=javascript.string_escape(url.toString(QUrl.FullyEncoded)))
+    """).render(
+        url=javascript.string_escape(url.toString(QUrl.FullyEncoded)),
+        # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70420
+        disable_create_object_url=(
+            not qtutils.version_check('5.12') and
+            objects.backend == usertypes.Backend.QtWebEngine))
 
 
 SYSTEM_PDFJS_PATHS = [

From 24148c649eb41fb98b6e3372390bbbb863d14414 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 22:06:56 +0200
Subject: [PATCH 16/39] Fix lint and tests

---
 qutebrowser/browser/downloads.py                       | 7 ++-----
 qutebrowser/browser/qutescheme.py                      | 1 -
 qutebrowser/browser/webengine/webenginedownloads.py    | 1 -
 qutebrowser/browser/webkit/network/webkitqutescheme.py | 4 +---
 tests/unit/browser/test_pdfjs.py                       | 2 --
 tests/unit/browser/webkit/test_downloads.py            | 4 ----
 6 files changed, 3 insertions(+), 16 deletions(-)

diff --git a/qutebrowser/browser/downloads.py b/qutebrowser/browser/downloads.py
index a2917e4f0..aa1140784 100644
--- a/qutebrowser/browser/downloads.py
+++ b/qutebrowser/browser/downloads.py
@@ -241,7 +241,6 @@ class FileDownloadTarget(_DownloadTarget):
     """
 
     def __init__(self, filename, force_overwrite=False):
-        # pylint: disable=super-init-not-called
         self.filename = filename
         self.force_overwrite = force_overwrite
 
@@ -261,7 +260,6 @@ class FileObjDownloadTarget(_DownloadTarget):
     """
 
     def __init__(self, fileobj):
-        # pylint: disable=super-init-not-called
         self.fileobj = fileobj
 
     def suggested_filename(self):
@@ -288,7 +286,6 @@ class OpenFileDownloadTarget(_DownloadTarget):
     """
 
     def __init__(self, cmdline=None):
-        # pylint: disable=super-init-not-called
         self.cmdline = cmdline
 
     def suggested_filename(self):
@@ -776,8 +773,8 @@ class AbstractDownloadItem(QObject):
                 return
 
             if isinstance(target, OpenFileDownloadTarget):
-                self.finished.connect(
-                    functools.partial(self._open_if_successful, target.cmdline))
+                self.finished.connect(functools.partial(
+                    self._open_if_successful, target.cmdline))
             elif isinstance(target, PDFJSDownloadTarget):
                 self.finished.connect(self._pdfjs_if_successful)
             else:
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 135089d11..41d2cabaf 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -48,7 +48,6 @@ from qutebrowser.browser import pdfjs
 from qutebrowser.config import config, configdata, configexc, configdiff
 from qutebrowser.utils import (version, utils, jinja, log, message, docutils,
                                objreg, urlutils)
-from qutebrowser.misc import objects
 from qutebrowser.qt import sip
 
 
diff --git a/qutebrowser/browser/webengine/webenginedownloads.py b/qutebrowser/browser/webengine/webenginedownloads.py
index 4b48e7be5..a9d44427d 100644
--- a/qutebrowser/browser/webengine/webenginedownloads.py
+++ b/qutebrowser/browser/webengine/webenginedownloads.py
@@ -225,7 +225,6 @@ class DownloadManager(downloads.AbstractDownloadManager):
             download.set_target(downloads.PDFJSDownloadTarget())
             return
 
-
         filename = downloads.immediate_download_path()
         if filename is not None:
             # User doesn't want to be asked, so just use the download_dir
diff --git a/qutebrowser/browser/webkit/network/webkitqutescheme.py b/qutebrowser/browser/webkit/network/webkitqutescheme.py
index 18473addf..319f96df2 100644
--- a/qutebrowser/browser/webkit/network/webkitqutescheme.py
+++ b/qutebrowser/browser/webkit/network/webkitqutescheme.py
@@ -19,14 +19,12 @@
 
 """QtWebKit specific qute://* handlers and glue code."""
 
-import mimetypes
-
 from PyQt5.QtCore import QUrl
 from PyQt5.QtNetwork import QNetworkReply, QNetworkAccessManager
 
 from qutebrowser.browser import qutescheme
 from qutebrowser.browser.webkit.network import networkreply
-from qutebrowser.utils import log, usertypes, qtutils
+from qutebrowser.utils import log, qtutils
 
 
 def handler(request, operation, current_url):
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index 594e69df6..c30d9fb08 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -17,8 +17,6 @@
 # You should have received a copy of the GNU General Public License
 # along with qutebrowser.  If not, see <http://www.gnu.org/licenses/>.
 
-import textwrap
-
 import pytest
 from PyQt5.QtCore import QUrl
 
diff --git a/tests/unit/browser/webkit/test_downloads.py b/tests/unit/browser/webkit/test_downloads.py
index 571e21704..b42caed00 100644
--- a/tests/unit/browser/webkit/test_downloads.py
+++ b/tests/unit/browser/webkit/test_downloads.py
@@ -68,10 +68,6 @@ def test_page_titles(url, title, out):
 
 class TestDownloadTarget:
 
-    def test_base(self):
-        with pytest.raises(NotImplementedError):
-            downloads._DownloadTarget()
-
     def test_filename(self):
         target = downloads.FileDownloadTarget("/foo/bar")
         assert target.filename == "/foo/bar"

From 490fe5e1a34c0ca4e1ec37de27a3d95d270548e7 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 22:13:56 +0200
Subject: [PATCH 17/39] Add utils.guess_mimetype

---
 qutebrowser/browser/qutescheme.py | 12 +++---------
 qutebrowser/utils/jinja.py        |  6 ++----
 qutebrowser/utils/utils.py        | 17 +++++++++++++++++
 tests/unit/utils/test_utils.py    | 13 +++++++++++++
 4 files changed, 35 insertions(+), 13 deletions(-)

diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index 41d2cabaf..dc952f0f8 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -29,7 +29,6 @@ import json
 import os
 import time
 import textwrap
-import mimetypes
 import urllib
 import collections
 import base64
@@ -368,8 +367,7 @@ def qute_help(url):
             bdata = utils.read_file(path, binary=True)
         except OSError as e:
             raise SchemeOSError(e)
-        mimetype, _encoding = mimetypes.guess_type(urlpath)
-        assert mimetype is not None, url
+        mimetype = utils.guess_mimetype(urlpath)
         return mimetype, bdata
 
     try:
@@ -527,9 +525,7 @@ def qute_pdfjs(url):
         filename = QUrlQuery(url).queryItemValue('filename')
         with open(filename, 'rb') as f:
             data = f.read()
-        mimetype, _encoding = mimetypes.guess_type(filename)
-        if mimetype is None:
-            mimetype = 'application/octet-stream'
+        mimetype = utils.guess_mimetype(filename, fallback=True)
         return mimetype, data
 
     if url.path() == '/web/viewer.html':
@@ -547,7 +543,5 @@ def qute_pdfjs(url):
             "pdfjs resource requested but not found: {}".format(e.path))
         raise NotFoundError("Can't find pdfjs resource '{}'".format(e.path))
     else:
-        mimetype, _encoding = mimetypes.guess_type(url.fileName())
-        if mimetype is None:
-            mimetype = 'application/octet-stream'
+        mimetype = utils.guess_mimetype(url.fileName(), fallback=True)
         return mimetype, data
diff --git a/qutebrowser/utils/jinja.py b/qutebrowser/utils/jinja.py
index b06444f93..d2ddfaeb7 100644
--- a/qutebrowser/utils/jinja.py
+++ b/qutebrowser/utils/jinja.py
@@ -22,7 +22,6 @@
 import os
 import os.path
 import contextlib
-import mimetypes
 import html
 
 import jinja2
@@ -108,9 +107,8 @@ class Environment(jinja2.Environment):
         """Get a data: url for the broken qutebrowser logo."""
         data = utils.read_file(path, binary=True)
         filename = utils.resource_filename(path)
-        mimetype = mimetypes.guess_type(filename)
-        assert mimetype is not None, path
-        return urlutils.data_url(mimetype[0], data).toString()
+        mimetype = utils.guess_mimetype(filename)
+        return urlutils.data_url(mimetype, data).toString()
 
     def getattr(self, obj, attribute):
         """Override jinja's getattr() to be less clever.
diff --git a/qutebrowser/utils/utils.py b/qutebrowser/utils/utils.py
index fe255331d..e9d4c3659 100644
--- a/qutebrowser/utils/utils.py
+++ b/qutebrowser/utils/utils.py
@@ -33,6 +33,7 @@ import contextlib
 import socket
 import shlex
 import glob
+import mimetypes
 
 from PyQt5.QtCore import QUrl
 from PyQt5.QtGui import QColor, QClipboard, QDesktopServices
@@ -683,3 +684,19 @@ def chunk(elems, n):
         raise ValueError("n needs to be at least 1!")
     for i in range(0, len(elems), n):
         yield elems[i:i + n]
+
+
+def guess_mimetype(filename, fallback=False):
+    """Guess a mimetype based on a filename.
+
+    Args:
+        filename: The filename to check.
+        fallback: Fall back to application/octet-stream if unknown.
+    """
+    mimetype, _encoding = mimetypes.guess_type(filename)
+    if mimetype is None:
+        if fallback:
+            return 'application/octet-stream'
+        else:
+            raise ValueError("Got None mimetype for {}".format(filename))
+    return mimetype
diff --git a/tests/unit/utils/test_utils.py b/tests/unit/utils/test_utils.py
index 550213386..e8a96d448 100644
--- a/tests/unit/utils/test_utils.py
+++ b/tests/unit/utils/test_utils.py
@@ -816,3 +816,16 @@ def test_chunk(elems, n, expected):
 def test_chunk_invalid(n):
     with pytest.raises(ValueError):
         list(utils.chunk([], n))
+
+
+@pytest.mark.parametrize('filename, expected', [
+    ('test.jpg', 'image/jpeg'),
+    ('test.blabla', 'application/octet-stream'),
+])
+def test_guess_mimetype(filename, expected):
+    assert utils.guess_mimetype(filename, fallback=True) == expected
+
+
+def test_guess_mimetype_no_fallback():
+    with pytest.raises(ValueError):
+        utils.guess_mimetype('test.blabla')

From 3e25262437346542343b0b203964094c5a78b9ec Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 22:14:35 +0200
Subject: [PATCH 18/39] Remove old backend patching

---
 tests/unit/browser/test_qutescheme.py | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/tests/unit/browser/test_qutescheme.py b/tests/unit/browser/test_qutescheme.py
index 9a21efc50..83cfdf1a6 100644
--- a/tests/unit/browser/test_qutescheme.py
+++ b/tests/unit/browser/test_qutescheme.py
@@ -185,11 +185,6 @@ class TestPDFJSHandler:
 
         monkeypatch.setattr(pdfjs, 'get_pdfjs_res', get_pdfjs_res)
 
-    @pytest.fixture(autouse=True)
-    def patch_backend(self, monkeypatch):
-        monkeypatch.setattr(qutescheme.objects, 'backend',
-                            usertypes.Backend.QtWebKit)
-
     def test_existing_resource(self):
         """Test with a resource that exists."""
         _mimetype, data = qutescheme.data_for_url(

From 24babe76a1099ca27b9f4e804c066fa26ab8e290 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Thu, 6 Sep 2018 23:05:04 +0200
Subject: [PATCH 19/39] Remove dead code

Thanks vulture!
---
 qutebrowser/browser/webkit/webpage.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/qutebrowser/browser/webkit/webpage.py b/qutebrowser/browser/webkit/webpage.py
index c0e3ce57b..7037f29fb 100644
--- a/qutebrowser/browser/webkit/webpage.py
+++ b/qutebrowser/browser/webkit/webpage.py
@@ -206,13 +206,6 @@ class BrowserPage(QWebPage):
                                                           suggested_file)
         return True
 
-    def _show_pdfjs(self, reply):
-        """Show the reply with pdfjs."""
-        page = pdfjs.generate_pdfjs_page(reply.url())
-        self.mainFrame().setContent(page.encode('utf-8'), 'text/html',
-                                    reply.url())
-        reply.deleteLater()
-
     def shutdown(self):
         """Prepare the web page for being deleted."""
         self._is_shutting_down = True

From 36ad2c45b5da1840747ee7c33426a4ff3ff7a2ac Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Fri, 7 Sep 2018 18:29:01 +0200
Subject: [PATCH 20/39] Clean up PDF.js snippet

---
 qutebrowser/browser/pdfjs.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 8fe628a02..602dda7e6 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -74,7 +74,9 @@ def _generate_pdfjs_script(url):
           PDFJS.disableCreateObjectURL = true;
           {% endif %}
           PDFJS.verbosity = PDFJS.VERBOSITY_LEVELS.info;
-          (window.PDFView || window.PDFViewerApplication).open("{{ url }}");
+
+          const viewer = window.PDFView || window.PDFViewerApplication;
+          viewer.open("{{ url }}");
         });
     """).render(
         url=javascript.string_escape(url.toString(QUrl.FullyEncoded)),

From f7169dc0ba2c72e13ae1df73660bc043c2834ace Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Fri, 7 Sep 2018 19:33:42 +0200
Subject: [PATCH 21/39] Enable content.pdfjs setting on QtWebEngine

---
 doc/help/settings.asciidoc        | 2 --
 qutebrowser/config/configdata.yml | 1 -
 2 files changed, 3 deletions(-)

diff --git a/doc/help/settings.asciidoc b/doc/help/settings.asciidoc
index d49c61ac5..333473dc7 100644
--- a/doc/help/settings.asciidoc
+++ b/doc/help/settings.asciidoc
@@ -1943,8 +1943,6 @@ Type: <<types,Bool>>
 
 Default: +pass:[false]+
 
-This setting is only available with the QtWebKit backend.
-
 [[content.persistent_storage]]
 === content.persistent_storage
 Allow websites to request persistent storage quota via `navigator.webkitPersistentStorage.requestQuota`.
diff --git a/qutebrowser/config/configdata.yml b/qutebrowser/config/configdata.yml
index 676b48026..b7648a4be 100644
--- a/qutebrowser/config/configdata.yml
+++ b/qutebrowser/config/configdata.yml
@@ -641,7 +641,6 @@ content.notifications:
 content.pdfjs:
   default: false
   type: Bool
-  backend: QtWebKit
   desc: >-
     Allow pdf.js to view PDF files in the browser.
 

From 8cfa46f539f4f14302480cb76ac029fe7353083e Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Fri, 7 Sep 2018 19:33:51 +0200
Subject: [PATCH 22/39] 100% test coverage for browser.pdfjs

---
 scripts/dev/check_coverage.py    |   2 +
 tests/unit/browser/test_pdfjs.py | 116 +++++++++++++++++++++++++++++++
 2 files changed, 118 insertions(+)

diff --git a/scripts/dev/check_coverage.py b/scripts/dev/check_coverage.py
index 8d6f3ccae..5c678ac96 100644
--- a/scripts/dev/check_coverage.py
+++ b/scripts/dev/check_coverage.py
@@ -64,6 +64,8 @@ PERFECT_FILES = [
      'browser/webkit/cookies.py'),
     ('tests/unit/browser/test_history.py',
      'browser/history.py'),
+    ('tests/unit/browser/test_pdfjs.py',
+     'browser/pdfjs.py'),
     ('tests/unit/browser/webkit/http/test_http.py',
      'browser/webkit/http.py'),
     ('tests/unit/browser/webkit/http/test_content_disposition.py',
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index c30d9fb08..02306c0ad 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -21,6 +21,18 @@ import pytest
 from PyQt5.QtCore import QUrl
 
 from qutebrowser.browser import pdfjs
+from qutebrowser.utils import usertypes
+
+
+@pytest.mark.parametrize('available, snippet', [
+    (True, '<title>PDF.js viewer</title>'),
+    (False, '<h1>No pdf.js installation found</h1>'),
+])
+def test_generate_pdfjs_page(available, snippet, monkeypatch):
+    monkeypatch.setattr(pdfjs, 'is_available', lambda: available)
+    content = pdfjs.generate_pdfjs_page(QUrl('https://example.com/'))
+    print(content)
+    assert snippet in content
 
 
 # Note that we got double protection, once because we use QUrl.FullyEncoded and
@@ -41,6 +53,60 @@ def test_generate_pdfjs_script(url, expected):
     assert 'PDFView' in actual
 
 
+@pytest.mark.parametrize('new_qt, backend, expected', [
+    (True, usertypes.Backend.QtWebEngine, False),
+    (True, usertypes.Backend.QtWebKit, False),
+    (False, usertypes.Backend.QtWebEngine, True),
+    (False, usertypes.Backend.QtWebKit, False),
+])
+def test_generate_pdfjs_script_disable_object_url(monkeypatch,
+                                                  new_qt, backend, expected):
+    monkeypatch.setattr(pdfjs.qtutils, 'version_check', lambda _v: new_qt)
+    monkeypatch.setattr(pdfjs.objects, 'backend', backend)
+
+    script = pdfjs._generate_pdfjs_script(QUrl('https://example.com/'))
+    assert ('PDFJS.disableCreateObjectURL' in script) == expected
+
+
+class TestResources:
+
+    @pytest.fixture
+    def read_system_mock(self, mocker):
+        return mocker.patch.object(pdfjs, '_read_from_system', autospec=True)
+
+    @pytest.fixture
+    def read_file_mock(self, mocker):
+        return mocker.patch.object(pdfjs.utils, 'read_file', autospec=True)
+
+    def test_get_pdfjs_res_system(self, read_system_mock):
+        read_system_mock.return_value = (b'content', 'path')
+
+        assert pdfjs.get_pdfjs_res_and_path('web/test') == (b'content', 'path')
+        assert pdfjs.get_pdfjs_res('web/test') == b'content'
+
+        read_system_mock.assert_called_with('/usr/share/pdf.js/',
+                                            ['web/test', 'test'])
+
+    def test_get_pdfjs_res_bundled(self, read_system_mock, read_file_mock):
+        read_system_mock.return_value = (None, None)
+
+        read_file_mock.return_value = b'content'
+
+        assert pdfjs.get_pdfjs_res_and_path('web/test') == (b'content', None)
+        assert pdfjs.get_pdfjs_res('web/test') == b'content'
+
+        for path in pdfjs.SYSTEM_PDFJS_PATHS:
+            read_system_mock.assert_any_call(path, ['web/test', 'test'])
+
+    def test_get_pdfjs_res_not_found(self, read_system_mock, read_file_mock):
+        read_system_mock.return_value = (None, None)
+        read_file_mock.side_effect = FileNotFoundError
+
+        with pytest.raises(pdfjs.PDFJSNotFound,
+                           match="Path 'web/test' not found"):
+            pdfjs.get_pdfjs_res_and_path('web/test')
+
+
 @pytest.mark.parametrize('path, expected', [
     ('web/viewer.js', 'viewer.js'),
     ('build/locale/foo.bar', 'locale/foo.bar'),
@@ -49,3 +115,53 @@ def test_generate_pdfjs_script(url, expected):
 ])
 def test_remove_prefix(path, expected):
     assert pdfjs._remove_prefix(path) == expected
+
+
+@pytest.mark.parametrize('names, expected_name', [
+    (['one'], 'one'),
+    (['doesnotexist', 'two'], 'two'),
+    (['one', 'two'], 'one'),
+    (['does', 'not', 'onexist'], None),
+])
+def test_read_from_system(names, expected_name, tmpdir):
+    file1 = tmpdir / 'one'
+    file1.write_text('text1', encoding='ascii')
+    file2 = tmpdir / 'two'
+    file2.write_text('text2', encoding='ascii')
+
+    if expected_name == 'one':
+        expected = (b'text1', str(file1))
+    elif expected_name == 'two':
+        expected = (b'text2', str(file2))
+    elif expected_name is None:
+        expected = (None, None)
+
+    assert pdfjs._read_from_system(str(tmpdir), names) == expected
+
+
+@pytest.mark.parametrize('available', [True, False])
+def test_is_available(available, mocker):
+    mock = mocker.patch.object(pdfjs, 'get_pdfjs_res', autospec=True)
+    if available:
+        mock.return_value = b'foo'
+    else:
+        mock.side_effect = pdfjs.PDFJSNotFound('build/pdf.js')
+
+    assert pdfjs.is_available() == available
+
+
+@pytest.mark.parametrize('mimetype, enabled, expected', [
+    ('application/pdf', True, True),
+    ('application/x-pdf', True, True),
+    ('application/octet-stream', True, False),
+    ('application/pdf', False, False),
+])
+def test_should_use_pdfjs(mimetype, enabled, expected, config_stub):
+    config_stub.val.content.pdfjs = enabled
+    assert pdfjs.should_use_pdfjs(mimetype) == expected
+
+
+def test_get_main_url():
+    expected = ('qute://pdfjs/web/viewer.html?file='
+                'qute://pdfjs/file?filename%3Dhello?world.pdf')
+    assert pdfjs.get_main_url('hello?world.pdf') == QUrl(expected)

From 231c1fbe594ecfd9357c70a3660d6bd929085d9f Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Sun, 9 Sep 2018 13:44:36 +0200
Subject: [PATCH 23/39] Add underscore to temporary download filename suffix

---
 qutebrowser/browser/downloads.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qutebrowser/browser/downloads.py b/qutebrowser/browser/downloads.py
index aa1140784..58b99a1d2 100644
--- a/qutebrowser/browser/downloads.py
+++ b/qutebrowser/browser/downloads.py
@@ -1265,7 +1265,7 @@ class TempDownloadManager:
         # Make sure that the filename is not too long
         suggested_name = utils.elide_filename(suggested_name, 50)
         fobj = tempfile.NamedTemporaryFile(dir=tmpdir.name, delete=False,
-                                           suffix=suggested_name)
+                                           suffix='_' + suggested_name)
         self.files.append(fobj)
         return fobj
 

From b96898db375e9d16eb95b8e35532d29306b529e8 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Sun, 9 Sep 2018 17:32:33 +0200
Subject: [PATCH 24/39] Simplify and lock down PDF.js filename handling

---
 qutebrowser/browser/downloads.py      |  6 +++---
 qutebrowser/browser/pdfjs.py          | 28 ++++++++++++++-------------
 qutebrowser/browser/qutescheme.py     | 20 ++++++++++++++-----
 tests/unit/browser/test_pdfjs.py      | 27 +++++++++++++-------------
 tests/unit/browser/test_qutescheme.py | 22 ++++++++++++++++++++-
 5 files changed, 67 insertions(+), 36 deletions(-)

diff --git a/qutebrowser/browser/downloads.py b/qutebrowser/browser/downloads.py
index 58b99a1d2..fddaa37ed 100644
--- a/qutebrowser/browser/downloads.py
+++ b/qutebrowser/browser/downloads.py
@@ -750,7 +750,7 @@ class AbstractDownloadItem(QObject):
         if filename is None:  # pragma: no cover
             log.downloads.error("No filename to open the download!")
             return
-        self.pdfjs_requested.emit(filename)
+        self.pdfjs_requested.emit(os.path.basename(filename))
 
     def set_target(self, target):
         """Set the target for a given download.
@@ -1233,7 +1233,7 @@ class TempDownloadManager:
                                    "directory")
             self._tmpdir = None
 
-    def _get_tmpdir(self):
+    def get_tmpdir(self):
         """Return the temporary directory that is used for downloads.
 
         The directory is created lazily on first access.
@@ -1259,7 +1259,7 @@ class TempDownloadManager:
         Return:
             A tempfile.NamedTemporaryFile that should be used to save the file.
         """
-        tmpdir = self._get_tmpdir()
+        tmpdir = self.get_tmpdir()
         encoding = sys.getfilesystemencoding()
         suggested_name = utils.force_encoding(suggested_name, encoding)
         # Make sure that the filename is not too long
diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index 602dda7e6..a0bad1cac 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -27,6 +27,7 @@ from PyQt5.QtCore import QUrl, QUrlQuery
 from qutebrowser.utils import utils, javascript, jinja, qtutils, usertypes
 from qutebrowser.misc import objects
 from qutebrowser.config import config
+from qutebrowser.browser import downloads
 
 
 class PDFJSNotFound(Exception):
@@ -43,31 +44,37 @@ class PDFJSNotFound(Exception):
         super().__init__(message)
 
 
-def generate_pdfjs_page(url):
-    """Return the html content of a page that displays url with pdfjs.
+def generate_pdfjs_page(filename, url):
+    """Return the html content of a page that displays a file with pdfjs.
 
     Returns a string.
 
     Args:
-        url: The url of the pdf as QUrl.
+        filename: The filename of the PDF to open.
+        url: The URL being opened.
     """
     if not is_available():
         return jinja.render('no_pdfjs.html',
                             url=url.toDisplayString(),
                             title="PDF.js not found")
     viewer = get_pdfjs_res('web/viewer.html').decode('utf-8')
-    script = _generate_pdfjs_script(url)
+    script = _generate_pdfjs_script(filename)
     html_page = viewer.replace('</body>',
                                '</body><script>{}</script>'.format(script))
     return html_page
 
 
-def _generate_pdfjs_script(url):
+def _generate_pdfjs_script(filename):
     """Generate the script that shows the pdf with pdf.js.
 
     Args:
-        url: The url of the pdf page as QUrl.
+        filename: The name of the file to open.
     """
+    url = QUrl('qute://pdfjs/file')
+    url_query = QUrlQuery()
+    url_query.addQueryItem('filename', filename)
+    url.setQuery(url_query)
+
     return jinja.js_environment.from_string("""
         document.addEventListener("DOMContentLoaded", function() {
           {% if disable_create_object_url %}
@@ -199,13 +206,8 @@ def should_use_pdfjs(mimetype):
 def get_main_url(filename):
     """Get the URL to be opened to view a local PDF."""
     url = QUrl('qute://pdfjs/web/viewer.html')
-
-    file_url = QUrl('qute://pdfjs/file')
-    file_url_query = QUrlQuery()
-    file_url_query.addQueryItem('filename', filename)
-    file_url.setQuery(file_url_query)
-
     query = QUrlQuery()
-    query.addQueryItem('file', file_url.toString())
+    query.addQueryItem('filename', filename)  # read from our JS
+    query.addQueryItem('file', '')  # to avoid pdfjs opening the default PDF
     url.setQuery(query)
     return url
diff --git a/qutebrowser/browser/qutescheme.py b/qutebrowser/browser/qutescheme.py
index dc952f0f8..5ff3f6fb0 100644
--- a/qutebrowser/browser/qutescheme.py
+++ b/qutebrowser/browser/qutescheme.py
@@ -43,7 +43,7 @@ import pkg_resources
 from PyQt5.QtCore import QUrlQuery, QUrl
 
 import qutebrowser
-from qutebrowser.browser import pdfjs
+from qutebrowser.browser import pdfjs, downloads
 from qutebrowser.config import config, configdata, configexc, configdiff
 from qutebrowser.utils import (version, utils, jinja, log, message, docutils,
                                objreg, urlutils)
@@ -520,17 +520,27 @@ def qute_pastebin_version(_url):
 @add_handler('pdfjs')
 def qute_pdfjs(url):
     """Handler for qute://pdfjs. Return the pdf.js viewer."""
-    # FIXME be more strict about allowed files here
     if url.path() == '/file':
         filename = QUrlQuery(url).queryItemValue('filename')
-        with open(filename, 'rb') as f:
+        if not filename:
+            raise UrlInvalidError("Missing filename")
+        if '/' in filename or os.sep in filename:
+            raise RequestDeniedError("Path separator in filename.")
+
+        path = os.path.join(downloads.temp_download_manager.get_tmpdir().name,
+                            filename)
+
+        with open(path, 'rb') as f:
             data = f.read()
+
         mimetype = utils.guess_mimetype(filename, fallback=True)
         return mimetype, data
 
     if url.path() == '/web/viewer.html':
-        filepath = QUrlQuery(url).queryItemValue("file")
-        data = pdfjs.generate_pdfjs_page(QUrl.fromLocalFile(filepath))
+        filename = QUrlQuery(url).queryItemValue("filename")
+        if not filename:
+            raise UrlInvalidError("Missing filename")
+        data = pdfjs.generate_pdfjs_page(filename, url)
         return 'text/html', data
 
     try:
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index 02306c0ad..be2070292 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -30,7 +30,7 @@ from qutebrowser.utils import usertypes
 ])
 def test_generate_pdfjs_page(available, snippet, monkeypatch):
     monkeypatch.setattr(pdfjs, 'is_available', lambda: available)
-    content = pdfjs.generate_pdfjs_page(QUrl('https://example.com/'))
+    content = pdfjs.generate_pdfjs_page('example.pdf', QUrl())
     print(content)
     assert snippet in content
 
@@ -38,17 +38,16 @@ def test_generate_pdfjs_page(available, snippet, monkeypatch):
 # Note that we got double protection, once because we use QUrl.FullyEncoded and
 # because we use qutebrowser.utils.javascript.string_escape.  Characters
 # like " are already replaced by QUrl.
-@pytest.mark.parametrize('url, expected', [
-    ('http://foo.bar', "http://foo.bar"),
-    ('http://"', ''),
-    ('\0', '%00'),
-    ('http://foobar/");alert("attack!");',
-     'http://foobar/%22);alert(%22attack!%22);'),
+@pytest.mark.parametrize('filename, expected', [
+    ('foo.bar', "foo.bar"),
+    ('foo"bar', "foo%22bar"),
+    ('foo\0bar', 'foo%00bar'),
+    ('foobar");alert("attack!");',
+     'foobar%22);alert(%22attack!%22);'),
 ])
-def test_generate_pdfjs_script(url, expected):
-    expected_open = 'open("{}");'.format(expected)
-    url = QUrl(url)
-    actual = pdfjs._generate_pdfjs_script(url)
+def test_generate_pdfjs_script(filename, expected):
+    expected_open = 'open("qute://pdfjs/file?filename={}");'.format(expected)
+    actual = pdfjs._generate_pdfjs_script(filename)
     assert expected_open in actual
     assert 'PDFView' in actual
 
@@ -64,7 +63,7 @@ def test_generate_pdfjs_script_disable_object_url(monkeypatch,
     monkeypatch.setattr(pdfjs.qtutils, 'version_check', lambda _v: new_qt)
     monkeypatch.setattr(pdfjs.objects, 'backend', backend)
 
-    script = pdfjs._generate_pdfjs_script(QUrl('https://example.com/'))
+    script = pdfjs._generate_pdfjs_script('testfile')
     assert ('PDFJS.disableCreateObjectURL' in script) == expected
 
 
@@ -162,6 +161,6 @@ def test_should_use_pdfjs(mimetype, enabled, expected, config_stub):
 
 
 def test_get_main_url():
-    expected = ('qute://pdfjs/web/viewer.html?file='
-                'qute://pdfjs/file?filename%3Dhello?world.pdf')
+    expected = ('qute://pdfjs/web/viewer.html?filename='
+                'hello?world.pdf&file=')
     assert pdfjs.get_main_url('hello?world.pdf') == QUrl(expected)
diff --git a/tests/unit/browser/test_qutescheme.py b/tests/unit/browser/test_qutescheme.py
index 83cfdf1a6..322939db0 100644
--- a/tests/unit/browser/test_qutescheme.py
+++ b/tests/unit/browser/test_qutescheme.py
@@ -22,10 +22,11 @@ import os
 import time
 import logging
 
+import py.path
 from PyQt5.QtCore import QUrl
 import pytest
 
-from qutebrowser.browser import qutescheme, pdfjs
+from qutebrowser.browser import qutescheme, pdfjs, downloads
 
 
 class TestJavascriptHandler:
@@ -185,6 +186,12 @@ class TestPDFJSHandler:
 
         monkeypatch.setattr(pdfjs, 'get_pdfjs_res', get_pdfjs_res)
 
+    @pytest.fixture
+    def download_tmpdir(self):
+        tdir = downloads.temp_download_manager.get_tmpdir()
+        yield py.path.local(tdir.name)
+        tdir.cleanup()
+
     def test_existing_resource(self):
         """Test with a resource that exists."""
         _mimetype, data = qutescheme.data_for_url(
@@ -199,3 +206,16 @@ class TestPDFJSHandler:
         assert len(caplog.records) == 1
         assert (caplog.records[0].message ==
                 'pdfjs resource requested but not found: /no/file.html')
+
+    def test_viewer_page(self):
+        """Load the /web/viewer.html page."""
+        _mimetype, data = qutescheme.data_for_url(
+            QUrl('qute://pdfjs/web/viewer.html?filename=foobar'))
+        assert b'PDF.js' in data
+
+    def test_file(self, download_tmpdir):
+        """Load a file via qute://pdfjs/file."""
+        (download_tmpdir / 'testfile').write_binary(b'foo')
+        _mimetype, data = qutescheme.data_for_url(
+            QUrl('qute://pdfjs/file?filename=testfile'))
+        assert data == b'foo'

From b4077a8543cc41ce2553f29c6c028e7c00411b6e Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Sun, 9 Sep 2018 17:59:18 +0200
Subject: [PATCH 25/39] Fix lint

---
 qutebrowser/browser/downloads.py      | 2 +-
 qutebrowser/browser/pdfjs.py          | 1 -
 tests/unit/browser/test_qutescheme.py | 4 ++--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/qutebrowser/browser/downloads.py b/qutebrowser/browser/downloads.py
index fddaa37ed..594bdf8bb 100644
--- a/qutebrowser/browser/downloads.py
+++ b/qutebrowser/browser/downloads.py
@@ -778,7 +778,7 @@ class AbstractDownloadItem(QObject):
             elif isinstance(target, PDFJSDownloadTarget):
                 self.finished.connect(self._pdfjs_if_successful)
             else:
-                assert False, target
+                raise utils.Unreachable
 
             self._set_tempfile(fobj)
         else:  # pragma: no cover
diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index a0bad1cac..db849cb04 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -27,7 +27,6 @@ from PyQt5.QtCore import QUrl, QUrlQuery
 from qutebrowser.utils import utils, javascript, jinja, qtutils, usertypes
 from qutebrowser.misc import objects
 from qutebrowser.config import config
-from qutebrowser.browser import downloads
 
 
 class PDFJSNotFound(Exception):
diff --git a/tests/unit/browser/test_qutescheme.py b/tests/unit/browser/test_qutescheme.py
index 322939db0..761769e16 100644
--- a/tests/unit/browser/test_qutescheme.py
+++ b/tests/unit/browser/test_qutescheme.py
@@ -22,7 +22,7 @@ import os
 import time
 import logging
 
-import py.path
+import py.path  # pylint: disable=no-name-in-module
 from PyQt5.QtCore import QUrl
 import pytest
 
@@ -189,7 +189,7 @@ class TestPDFJSHandler:
     @pytest.fixture
     def download_tmpdir(self):
         tdir = downloads.temp_download_manager.get_tmpdir()
-        yield py.path.local(tdir.name)
+        yield py.path.local(tdir.name)  # pylint: disable=no-member
         tdir.cleanup()
 
     def test_existing_resource(self):

From 9b04c4b8e0dd1bd36a97fd8e64ef88d6f185e215 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Sun, 9 Sep 2018 19:22:39 +0200
Subject: [PATCH 26/39] Add missing tests for qute://pdfjs

---
 tests/unit/browser/test_qutescheme.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/tests/unit/browser/test_qutescheme.py b/tests/unit/browser/test_qutescheme.py
index 761769e16..db8f9b29b 100644
--- a/tests/unit/browser/test_qutescheme.py
+++ b/tests/unit/browser/test_qutescheme.py
@@ -23,7 +23,7 @@ import time
 import logging
 
 import py.path  # pylint: disable=no-name-in-module
-from PyQt5.QtCore import QUrl
+from PyQt5.QtCore import QUrl, QUrlQuery
 import pytest
 
 from qutebrowser.browser import qutescheme, pdfjs, downloads
@@ -213,9 +213,26 @@ class TestPDFJSHandler:
             QUrl('qute://pdfjs/web/viewer.html?filename=foobar'))
         assert b'PDF.js' in data
 
+    def test_viewer_no_filename(self):
+        with pytest.raises(qutescheme.UrlInvalidError):
+            qutescheme.data_for_url(QUrl('qute://pdfjs/web/viewer.html'))
+
     def test_file(self, download_tmpdir):
         """Load a file via qute://pdfjs/file."""
         (download_tmpdir / 'testfile').write_binary(b'foo')
         _mimetype, data = qutescheme.data_for_url(
             QUrl('qute://pdfjs/file?filename=testfile'))
         assert data == b'foo'
+
+    def test_file_no_filename(self):
+        with pytest.raises(qutescheme.UrlInvalidError):
+            qutescheme.data_for_url(QUrl('qute://pdfjs/file'))
+
+    @pytest.mark.parametrize('sep', ['/', os.sep])
+    def test_file_pathsep(self, sep):
+        url = QUrl('qute://pdfjs/file')
+        query = QUrlQuery()
+        query.addQueryItem('filename', 'foo{}bar'.format(sep))
+        url.setQuery(query)
+        with pytest.raises(qutescheme.RequestDeniedError):
+            qutescheme.data_for_url(url)

From 1b618b2501670c3481d78d63eb5ae91c23d14fbd Mon Sep 17 00:00:00 2001
From: Michael Hoang <enzime@users.noreply.github.com>
Date: Sun, 9 Sep 2018 19:30:57 +1000
Subject: [PATCH 27/39] Set maxsplit to 0 on :tab-take

---
 qutebrowser/browser/commands.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index d5e1797ac..d453c6a4f 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -485,7 +485,8 @@ class CommandDispatcher:
         new_tabbed_browser.widget.set_tab_pinned(newtab, curtab.data.pinned)
         return newtab
 
-    @cmdutils.register(instance='command-dispatcher', scope='window')
+    @cmdutils.register(instance='command-dispatcher', scope='window',
+                       maxsplit=0)
     @cmdutils.argument('index', completion=miscmodels.other_buffer)
     def tab_take(self, index):
         """Take a tab from another window.

From bb96f8d297aa04a58c92befdefc3d5d39e98d858 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Mon, 10 Sep 2018 09:36:29 +0200
Subject: [PATCH 28/39] Fix PDF.js test when no PDF.js is installed

---
 tests/unit/browser/test_pdfjs.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index be2070292..43bb2c38e 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -25,11 +25,20 @@ from qutebrowser.utils import usertypes
 
 
 @pytest.mark.parametrize('available, snippet', [
-    (True, '<title>PDF.js viewer</title>'),
+    pytest.param(True, '<title>PDF.js viewer</title>',
+                 marks=pytest.mark.skipif(not pdfjs.is_available(),
+                                          reason='PDF.js unavailable')),
     (False, '<h1>No pdf.js installation found</h1>'),
+    ('force', 'fake PDF.js'),
 ])
 def test_generate_pdfjs_page(available, snippet, monkeypatch):
-    monkeypatch.setattr(pdfjs, 'is_available', lambda: available)
+    if available == 'force':
+        monkeypatch.setattr(pdfjs, 'is_available', lambda: True)
+        monkeypatch.setattr(pdfjs, 'get_pdfjs_res',
+                            lambda filename: b'fake PDF.js')
+    else:
+        monkeypatch.setattr(pdfjs, 'is_available', lambda: available)
+
     content = pdfjs.generate_pdfjs_page('example.pdf', QUrl())
     print(content)
     assert snippet in content

From 3138c1f488886a2d2d0cce55788039b166cb9979 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Mon, 10 Sep 2018 11:58:27 +0200
Subject: [PATCH 29/39] Update changelog

---
 doc/changelog.asciidoc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/changelog.asciidoc b/doc/changelog.asciidoc
index 7b98ea71d..04fbbafd4 100644
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
@@ -27,6 +27,11 @@ Added
 - New `content.mouse_lock` setting to handle HTML5 pointer locking.
 - New `completion.web_history.exclude` setting which hides a list of URL
   patterns from the completion.
+- Rewritten PDF.js support:
+  * PDF.js support and the `content.pdfjs` setting are now available with
+    QtWebEngine.
+  * Opening a PDF file now doesn't start a second request anymore.
+  * Opening PDFs on https:// sites now works properly.
 
 Changed
 ~~~~~~~

From 02641b86fc14ab44ca5792f038ba73682d86d45d Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Mon, 10 Sep 2018 13:01:01 +0200
Subject: [PATCH 30/39] Don't tell PDF.js to disable createObjectURL on Qt
 5.7.1

Looks like things actually work fine there...
---
 qutebrowser/browser/pdfjs.py     |  1 +
 tests/unit/browser/test_pdfjs.py | 31 +++++++++++++++++++++++--------
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index db849cb04..da6dcbfe6 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -89,6 +89,7 @@ def _generate_pdfjs_script(filename):
         # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70420
         disable_create_object_url=(
             not qtutils.version_check('5.12') and
+            not qtutils.version_check('5.7.1', exact=True, compiled=False) and
             objects.backend == usertypes.Backend.QtWebEngine))
 
 
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index 43bb2c38e..ff62545bd 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -21,7 +21,7 @@ import pytest
 from PyQt5.QtCore import QUrl
 
 from qutebrowser.browser import pdfjs
-from qutebrowser.utils import usertypes
+from qutebrowser.utils import usertypes, utils
 
 
 @pytest.mark.parametrize('available, snippet', [
@@ -61,15 +61,30 @@ def test_generate_pdfjs_script(filename, expected):
     assert 'PDFView' in actual
 
 
-@pytest.mark.parametrize('new_qt, backend, expected', [
-    (True, usertypes.Backend.QtWebEngine, False),
-    (True, usertypes.Backend.QtWebKit, False),
-    (False, usertypes.Backend.QtWebEngine, True),
-    (False, usertypes.Backend.QtWebKit, False),
+@pytest.mark.parametrize('qt, backend, expected', [
+    ('new', usertypes.Backend.QtWebEngine, False),
+    ('new', usertypes.Backend.QtWebKit, False),
+    ('old', usertypes.Backend.QtWebEngine, True),
+    ('old', usertypes.Backend.QtWebKit, False),
+    ('5.7', usertypes.Backend.QtWebEngine, False),
+    ('5.7', usertypes.Backend.QtWebKit, False),
 ])
 def test_generate_pdfjs_script_disable_object_url(monkeypatch,
-                                                  new_qt, backend, expected):
-    monkeypatch.setattr(pdfjs.qtutils, 'version_check', lambda _v: new_qt)
+                                                  qt, backend, expected):
+    if qt == 'new':
+        monkeypatch.setattr(pdfjs.qtutils, 'version_check',
+                            lambda version, exact=False, compiled=True:
+                            False if version == '5.7.1' else True)
+    elif qt == 'old':
+        monkeypatch.setattr(pdfjs.qtutils, 'version_check',
+                            lambda version, exact=False, compiled=True: False)
+    elif qt == '5.7':
+        monkeypatch.setattr(pdfjs.qtutils, 'version_check',
+                            lambda version, exact=False, compiled=True:
+                            True if version == '5.7.1' else False)
+    else:
+        raise utils.Unreachable
+
     monkeypatch.setattr(pdfjs.objects, 'backend', backend)
 
     script = pdfjs._generate_pdfjs_script('testfile')

From d80d9eb26c6263a68a7bbbaf344afba3c5f282e9 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Mon, 10 Sep 2018 13:15:39 +0200
Subject: [PATCH 31/39] Allow downloading from PDF.js

When we click the download button in PDF.js, it downloads a blob://qute:...
URL. We can detect that and force a download rather than opening it in PDF.js
again.

Note that what actually happens depends on the Qt version and backend:

QtWebKit (any Qt version):
Downloads always work properly (regardless of Qt version).

QtWebEngine, Qt 5.7.1:
Downloads work.

QtWebEngine, Qt 5.9 - 5.11:
Downloads won't work as we need to tell PDF.js to not use blob: URLs:
https://bugreports.qt.io/browse/QTBUG-70420 - in theory, PDF.js could fall back
to downloading the existing qute:// URL, but it has a whitelist of schemes
which does not include qute://... Since it's not in that whitelist, it just
ends up doing nothing at all.

QtWebEngine, Qt 5.12:
Downloads should hopefully work properly again, as we can register the qute://
scheme with Chromium, which allows us to use blob:// URLs.
---
 qutebrowser/browser/pdfjs.py                  |  9 ++++++---
 .../browser/webengine/webenginedownloads.py   |  2 +-
 qutebrowser/browser/webkit/webpage.py         |  2 +-
 tests/unit/browser/test_pdfjs.py              | 19 ++++++++++++-------
 4 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index da6dcbfe6..c6eef53d9 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -198,9 +198,12 @@ def is_available():
         return True
 
 
-def should_use_pdfjs(mimetype):
-    return (mimetype in ['application/pdf', 'application/x-pdf'] and
-            config.val.content.pdfjs)
+def should_use_pdfjs(mimetype, url):
+    # e.g. 'blob:qute%3A///b45250b3-787e-44d1-a8d8-c2c90f81f981'
+    is_download_url = (url.scheme() == 'blob' and
+                       QUrl(url.path()).scheme() == 'qute')
+    is_pdf = mimetype in ['application/pdf', 'application/x-pdf']
+    return is_pdf and not is_download_url and config.val.content.pdfjs
 
 
 def get_main_url(filename):
diff --git a/qutebrowser/browser/webengine/webenginedownloads.py b/qutebrowser/browser/webengine/webenginedownloads.py
index a9d44427d..3f47dd640 100644
--- a/qutebrowser/browser/webengine/webenginedownloads.py
+++ b/qutebrowser/browser/webengine/webenginedownloads.py
@@ -221,7 +221,7 @@ class DownloadManager(downloads.AbstractDownloadManager):
             download.set_target(self._mhtml_target)
             self._mhtml_target = None
             return
-        if pdfjs.should_use_pdfjs(qt_item.mimeType()):
+        if pdfjs.should_use_pdfjs(qt_item.mimeType(), qt_item.url()):
             download.set_target(downloads.PDFJSDownloadTarget())
             return
 
diff --git a/qutebrowser/browser/webkit/webpage.py b/qutebrowser/browser/webkit/webpage.py
index 7037f29fb..63017ec45 100644
--- a/qutebrowser/browser/webkit/webpage.py
+++ b/qutebrowser/browser/webkit/webpage.py
@@ -268,7 +268,7 @@ class BrowserPage(QWebPage):
             else:
                 reply.finished.connect(functools.partial(
                     self.display_content, reply, 'image/jpeg'))
-        elif pdfjs.should_use_pdfjs(mimetype):
+        elif pdfjs.should_use_pdfjs(mimetype, reply.url()):
             download_manager.fetch(reply,
                                    target=downloads.PDFJSDownloadTarget())
         else:
diff --git a/tests/unit/browser/test_pdfjs.py b/tests/unit/browser/test_pdfjs.py
index ff62545bd..91536e416 100644
--- a/tests/unit/browser/test_pdfjs.py
+++ b/tests/unit/browser/test_pdfjs.py
@@ -173,15 +173,20 @@ def test_is_available(available, mocker):
     assert pdfjs.is_available() == available
 
 
-@pytest.mark.parametrize('mimetype, enabled, expected', [
-    ('application/pdf', True, True),
-    ('application/x-pdf', True, True),
-    ('application/octet-stream', True, False),
-    ('application/pdf', False, False),
+@pytest.mark.parametrize('mimetype, url, enabled, expected', [
+    # PDF files
+    ('application/pdf', 'http://www.example.com', True, True),
+    ('application/x-pdf', 'http://www.example.com', True, True),
+    # Not a PDF
+    ('application/octet-stream', 'http://www.example.com', True, False),
+    # PDF.js disabled
+    ('application/pdf', 'http://www.example.com', False, False),
+    # Download button in PDF.js
+    ('application/pdf', 'blob:qute%3A///b45250b3', True, False),
 ])
-def test_should_use_pdfjs(mimetype, enabled, expected, config_stub):
+def test_should_use_pdfjs(mimetype, url, enabled, expected, config_stub):
     config_stub.val.content.pdfjs = enabled
-    assert pdfjs.should_use_pdfjs(mimetype) == expected
+    assert pdfjs.should_use_pdfjs(mimetype, QUrl(url)) == expected
 
 
 def test_get_main_url():

From 6a480564cbe8675be0f9dce069e4a515829b0f57 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Tue, 11 Sep 2018 19:44:37 +0200
Subject: [PATCH 32/39] Fix docs to say XDG_DATA_HOME instead of _DIR

---
 doc/changelog.asciidoc              | 2 +-
 doc/help/commands.asciidoc          | 4 ++--
 qutebrowser/browser/commands.py     | 2 +-
 qutebrowser/browser/hints.py        | 2 +-
 qutebrowser/commands/userscripts.py | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/changelog.asciidoc b/doc/changelog.asciidoc
index 04fbbafd4..4c11e91cf 100644
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
@@ -1631,7 +1631,7 @@ Changed
   `tabs.bg/fg.selected.odd/even`.
 - `:spawn --userscript` and `:hint` with the `userscript` target now look up
   relative paths in `~/.local/share/qutebrowser/userscripts` or
-  `$XDG_DATA_DIR`. Using a binary in `$PATH` won't work anymore with
+  `$XDG_DATA_HOME`. Using a binary in `$PATH` won't work anymore with
   `--userscript`.
 - New design for error pages
 - Link filtering for hints now checks if the text is contained anywhere in
diff --git a/doc/help/commands.asciidoc b/doc/help/commands.asciidoc
index 4b4ad54bc..a4a65315c 100644
--- a/doc/help/commands.asciidoc
+++ b/doc/help/commands.asciidoc
@@ -576,7 +576,7 @@ Start hinting.
  - With `userscript`: The userscript to execute. Either store
  the userscript in
  `~/.local/share/qutebrowser/userscripts`
- (or `$XDG_DATA_DIR`), or use an absolute
+ (or `$XDG_DATA_HOME`), or use an absolute
  path.
  - With `fill`: The command to fill the statusbar with.
  `{hint-url}` will get replaced by the selected
@@ -1193,7 +1193,7 @@ Spawn a command in a shell.
 * +*-u*+, +*--userscript*+: Run the command as a userscript. You can use an absolute path, or store the userscript in one of those
  locations:
  - `~/.local/share/qutebrowser/userscripts`
- (or `$XDG_DATA_DIR`)
+ (or `$XDG_DATA_HOME`)
  - `/usr/share/qutebrowser/userscripts`
 
 * +*-v*+, +*--verbose*+: Show notifications when the command started/exited.
diff --git a/qutebrowser/browser/commands.py b/qutebrowser/browser/commands.py
index d5e1797ac..441e88dbc 100644
--- a/qutebrowser/browser/commands.py
+++ b/qutebrowser/browser/commands.py
@@ -1183,7 +1183,7 @@ class CommandDispatcher:
                         absolute path, or store the userscript in one of those
                         locations:
                             - `~/.local/share/qutebrowser/userscripts`
-                              (or `$XDG_DATA_DIR`)
+                              (or `$XDG_DATA_HOME`)
                             - `/usr/share/qutebrowser/userscripts`
             verbose: Show notifications when the command started/exited.
             output: Whether the output should be shown in a new tab.
diff --git a/qutebrowser/browser/hints.py b/qutebrowser/browser/hints.py
index 6e5f4d7f4..00481c2f4 100644
--- a/qutebrowser/browser/hints.py
+++ b/qutebrowser/browser/hints.py
@@ -693,7 +693,7 @@ class HintManager(QObject):
                 - With `userscript`: The userscript to execute. Either store
                                      the userscript in
                                      `~/.local/share/qutebrowser/userscripts`
-                                     (or `$XDG_DATA_DIR`), or use an absolute
+                                     (or `$XDG_DATA_HOME`), or use an absolute
                                      path.
                 - With `fill`: The command to fill the statusbar with.
                                 `{hint-url}` will get replaced by the selected
diff --git a/qutebrowser/commands/userscripts.py b/qutebrowser/commands/userscripts.py
index 5654fd809..8d95db07d 100644
--- a/qutebrowser/commands/userscripts.py
+++ b/qutebrowser/commands/userscripts.py
@@ -432,7 +432,7 @@ def run_async(tab, cmd, *args, win_id, env, verbose=False):
     cmd_path = os.path.expanduser(cmd)
 
     # if cmd is not given as an absolute path, look it up
-    # ~/.local/share/qutebrowser/userscripts (or $XDG_DATA_DIR)
+    # ~/.local/share/qutebrowser/userscripts (or $XDG_DATA_HOME)
     if not os.path.isabs(cmd_path):
         log.misc.debug("{} is no absolute path".format(cmd_path))
         cmd_path = _lookup_path(cmd)

From 941be6faedb79a564dbf7ad982992a5b2b2030a6 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Tue, 11 Sep 2018 20:45:15 +0200
Subject: [PATCH 33/39] Add docstring

---
 qutebrowser/browser/pdfjs.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/qutebrowser/browser/pdfjs.py b/qutebrowser/browser/pdfjs.py
index c6eef53d9..ee291d4eb 100644
--- a/qutebrowser/browser/pdfjs.py
+++ b/qutebrowser/browser/pdfjs.py
@@ -199,6 +199,7 @@ def is_available():
 
 
 def should_use_pdfjs(mimetype, url):
+    """Check whether PDF.js should be used."""
     # e.g. 'blob:qute%3A///b45250b3-787e-44d1-a8d8-c2c90f81f981'
     is_download_url = (url.scheme() == 'blob' and
                        QUrl(url.path()).scheme() == 'qute')

From d298d49f6f40dfc5bbe03e114bbb0aa157e4d54d Mon Sep 17 00:00:00 2001
From: Jay Kamat <jaygkamat@gmail.com>
Date: Tue, 11 Sep 2018 15:26:38 -0700
Subject: [PATCH 34/39] Update changelog

---
 doc/changelog.asciidoc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/changelog.asciidoc b/doc/changelog.asciidoc
index 1fc848a1e..17135a149 100644
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
@@ -49,6 +49,11 @@ Changed
 - Regenerating completion history now shows a progress dialog.
 - Make qute:// pages work properly on Qt 5.11.2
 
+Fixed
+~~~~~
+
+- Error when passing a substring with spaces to `:tab-take`.
+
 Removed
 ~~~~~~~
 

From c8b447daec7f5809f7af5bb7a476b9a1bf5f94b5 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 12 Sep 2018 01:31:41 +0200
Subject: [PATCH 35/39] Clean up raise_sqlite_error

---
 qutebrowser/misc/sql.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/qutebrowser/misc/sql.py b/qutebrowser/misc/sql.py
index 8053e5151..60171a326 100644
--- a/qutebrowser/misc/sql.py
+++ b/qutebrowser/misc/sql.py
@@ -86,12 +86,16 @@ class SqlBugError(SqlError):
 
 def raise_sqlite_error(msg, error):
     """Raise either a SqlBugError or SqlEnvironmentError."""
+    error_code = error.nativeErrorCode()
+    database_text = error.databaseText()
+
     log.sql.debug("SQL error:")
     log.sql.debug("type: {}".format(
         debug.qenum_key(QSqlError, error.type())))
-    log.sql.debug("database text: {}".format(error.databaseText()))
+    log.sql.debug("database text: {}".format(database_text))
     log.sql.debug("driver text: {}".format(error.driverText()))
-    log.sql.debug("error code: {}".format(error.nativeErrorCode()))
+    log.sql.debug("error code: {}".format(error_code))
+
     environmental_errors = [
         SqliteErrorCode.BUSY,
         SqliteErrorCode.READONLY,
@@ -108,9 +112,9 @@ def raise_sqlite_error(msg, error):
     environmental_strings = [
         "out of memory",
     ]
-    errcode = error.nativeErrorCode()
-    if (errcode in environmental_errors or
-            (errcode == -1 and error.databaseText() in environmental_strings)):
+
+    if (error_code in environmental_errors or
+            (error_code == -1 and database_text in environmental_strings)):
         raise SqlEnvironmentError(msg, error)
     else:
         raise SqlBugError(msg, error)

From c2a072f9fe4e62171bc57db52adaa65f1a170f89 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 12 Sep 2018 01:36:50 +0200
Subject: [PATCH 36/39] Fix handling of sqlite out of memory errors

The "error_code == -1" check never passed, as error_code (confusingly) is a
string of a number.
---
 qutebrowser/misc/sql.py     | 4 +++-
 tests/unit/misc/test_sql.py | 9 +++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/qutebrowser/misc/sql.py b/qutebrowser/misc/sql.py
index 60171a326..0f4baac55 100644
--- a/qutebrowser/misc/sql.py
+++ b/qutebrowser/misc/sql.py
@@ -35,6 +35,7 @@ class SqliteErrorCode:
     in qutebrowser here.
     """
 
+    UNKNOWN = '-1'
     BUSY = '5'  # database is locked
     READONLY = '8'  # attempt to write a readonly database
     IOERR = '10'  # disk I/O error
@@ -114,7 +115,8 @@ def raise_sqlite_error(msg, error):
     ]
 
     if (error_code in environmental_errors or
-            (error_code == -1 and database_text in environmental_strings)):
+            (error_code == SqliteErrorCode.UNKNOWN and
+             database_text in environmental_strings)):
         raise SqlEnvironmentError(msg, error)
     else:
         raise SqlBugError(msg, error)
diff --git a/tests/unit/misc/test_sql.py b/tests/unit/misc/test_sql.py
index 82c33841f..149d44a98 100644
--- a/tests/unit/misc/test_sql.py
+++ b/tests/unit/misc/test_sql.py
@@ -49,6 +49,15 @@ class TestSqlError:
         with pytest.raises(exception):
             sql.raise_sqlite_error("Message", sql_err)
 
+    def test_out_of_memory(self):
+        """On out of memory error, we get an error code '-1' from Qt."""
+        sql_err = QSqlError("driver text",
+                            "out of memory",
+                            QSqlError.UnknownError,
+                            sql.SqliteErrorCode.UNKNOWN)
+        with pytest.raises(sql.SqlEnvironmentError):
+            sql.raise_sqlite_error("Message", sql_err)
+
     def test_logging(self, caplog):
         sql_err = QSqlError("driver text", "db text", QSqlError.UnknownError,
                             '23')

From 91b8002dd5ff46256f66f6eec34ef525daa9d3c5 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 12 Sep 2018 10:48:43 +0200
Subject: [PATCH 37/39] Clean up workaround for sqlite opening errors

Now that we know the real cause, we can be a bit stricter with our workaround.
---
 qutebrowser/misc/sql.py     | 22 ++++++++++------------
 tests/unit/misc/test_sql.py | 10 +++++++---
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/qutebrowser/misc/sql.py b/qutebrowser/misc/sql.py
index 0f4baac55..4c300a3da 100644
--- a/qutebrowser/misc/sql.py
+++ b/qutebrowser/misc/sql.py
@@ -89,12 +89,13 @@ def raise_sqlite_error(msg, error):
     """Raise either a SqlBugError or SqlEnvironmentError."""
     error_code = error.nativeErrorCode()
     database_text = error.databaseText()
+    driver_text = error.driverText()
 
     log.sql.debug("SQL error:")
     log.sql.debug("type: {}".format(
         debug.qenum_key(QSqlError, error.type())))
     log.sql.debug("database text: {}".format(database_text))
-    log.sql.debug("driver text: {}".format(error.driverText()))
+    log.sql.debug("driver text: {}".format(driver_text))
     log.sql.debug("error code: {}".format(error_code))
 
     environmental_errors = [
@@ -105,18 +106,15 @@ def raise_sqlite_error(msg, error):
         SqliteErrorCode.FULL,
         SqliteErrorCode.CANTOPEN,
     ]
-    # At least in init(), we can get errors like this:
-    # > type: ConnectionError
-    # > database text: out of memory
-    # > driver text: Error opening database
-    # > error code: -1
-    environmental_strings = [
-        "out of memory",
-    ]
 
-    if (error_code in environmental_errors or
-            (error_code == SqliteErrorCode.UNKNOWN and
-             database_text in environmental_strings)):
+    # WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70506
+    # We don't know what the actual error was, but let's assume it's not us to
+    # blame... Usually this is something like an unreadable database file.
+    qtbug_70506 = (error_code == SqliteErrorCode.UNKNOWN and
+                   driver_text == "Error opening database" and
+                   database_text == "out of memory")
+
+    if error_code in environmental_errors or qtbug_70506:
         raise SqlEnvironmentError(msg, error)
     else:
         raise SqlBugError(msg, error)
diff --git a/tests/unit/misc/test_sql.py b/tests/unit/misc/test_sql.py
index 149d44a98..54c785286 100644
--- a/tests/unit/misc/test_sql.py
+++ b/tests/unit/misc/test_sql.py
@@ -49,9 +49,13 @@ class TestSqlError:
         with pytest.raises(exception):
             sql.raise_sqlite_error("Message", sql_err)
 
-    def test_out_of_memory(self):
-        """On out of memory error, we get an error code '-1' from Qt."""
-        sql_err = QSqlError("driver text",
+    def test_qtbug_70506(self):
+        """Test Qt's wrong handling of errors while opening the database.
+
+        Due to https://bugreports.qt.io/browse/QTBUG-70506 we get an error with
+        "out of memory" as string and -1 as error code.
+        """
+        sql_err = QSqlError("Error opening database",
                             "out of memory",
                             QSqlError.UnknownError,
                             sql.SqliteErrorCode.UNKNOWN)

From d0d73eec04e97a1ae20d761d9055a89379efcb70 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 12 Sep 2018 16:07:25 +0200
Subject: [PATCH 38/39] Regenerate docs

---
 doc/help/commands.asciidoc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/doc/help/commands.asciidoc b/doc/help/commands.asciidoc
index a4a65315c..51d3b30a9 100644
--- a/doc/help/commands.asciidoc
+++ b/doc/help/commands.asciidoc
@@ -1342,6 +1342,9 @@ Take a tab from another window.
 * +'index'+: The [win_id/]index of the tab to take. Or a substring in which case the closest match will be taken.
 
 
+==== note
+* This command does not split arguments after the last argument and handles quotes literally.
+
 [[unbind]]
 === unbind
 Syntax: +:unbind [*--mode* 'mode'] 'key'+

From f9327731b85cb80d3f7d370b67f11db29d456b27 Mon Sep 17 00:00:00 2001
From: Florian Bruhin <me@the-compiler.org>
Date: Wed, 12 Sep 2018 23:54:32 +0200
Subject: [PATCH 39/39] Handle UTF-8 byte order marks in Greasemonkey scripts

See e.g. https://github.com/jerone/UserScripts/issues/135
---
 doc/changelog.asciidoc                     |  1 +
 qutebrowser/browser/greasemonkey.py        |  2 +-
 tests/unit/javascript/test_greasemonkey.py | 20 ++++++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/doc/changelog.asciidoc b/doc/changelog.asciidoc
index 57c95c8f3..0ec1d8003 100644
--- a/doc/changelog.asciidoc
+++ b/doc/changelog.asciidoc
@@ -59,6 +59,7 @@ Fixed
 ~~~~~
 
 - Error when passing a substring with spaces to `:tab-take`.
+- Greasemonkey scripts which start with an UTF-8 BOM are now handled correctly.
 
 Removed
 ~~~~~~~
diff --git a/qutebrowser/browser/greasemonkey.py b/qutebrowser/browser/greasemonkey.py
index 7e5ff7f5b..d48e6db1f 100644
--- a/qutebrowser/browser/greasemonkey.py
+++ b/qutebrowser/browser/greasemonkey.py
@@ -234,7 +234,7 @@ class GreasemonkeyManager(QObject):
             if not os.path.isfile(script_filename):
                 continue
             script_path = os.path.join(scripts_dir, script_filename)
-            with open(script_path, encoding='utf-8') as script_file:
+            with open(script_path, encoding='utf-8-sig') as script_file:
                 script = GreasemonkeyScript.parse(script_file.read())
                 if not script.name:
                     script.name = script_filename
diff --git a/tests/unit/javascript/test_greasemonkey.py b/tests/unit/javascript/test_greasemonkey.py
index 15fa4321e..79983a5c9 100644
--- a/tests/unit/javascript/test_greasemonkey.py
+++ b/tests/unit/javascript/test_greasemonkey.py
@@ -130,6 +130,26 @@ def test_load_emits_signal(qtbot):
         gm_manager.load_scripts()
 
 
+def test_utf8_bom():
+    """Make sure UTF-8 BOMs are stripped from scripts.
+
+    If we don't strip them, we'll have a BOM in the middle of the file, causing
+    QtWebEngine to not catch the "// ==UserScript==" line.
+    """
+    script = textwrap.dedent("""
+        \N{BYTE ORDER MARK}// ==UserScript==
+        // @name qutebrowser test userscript
+        // ==/UserScript==
+    """.lstrip('\n'))
+    _save_script(script, 'bom.user.js')
+    gm_manager = greasemonkey.GreasemonkeyManager()
+
+    scripts = gm_manager.all_scripts()
+    assert len(scripts) == 1
+    script = scripts[0]
+    assert '// ==UserScript==' in script.code().splitlines()
+
+
 def test_required_scripts_are_included(download_stub, tmpdir):
     test_require_script = textwrap.dedent("""
         // ==UserScript==