def install(self, profile):
"""Install the handler for glimpse:// URLs on the given profile."""
if QWebEngineUrlScheme is not None:
assert QWebEngineUrlScheme.schemeByName(b'glimpse') is not None
profile.installUrlSchemeHandler(b'glimpse', self)
if (qtutils.version_check('5.11', compiled=False)
and not qtutils.version_check('5.12', compiled=False)):
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-63378
profile.installUrlSchemeHandler(b'chrome-error', self)
profile.installUrlSchemeHandler(b'chrome-extension', self)
def _apply_platform_markers(config, item):
"""Apply a skip marker to a given item."""
markers = [
('posix', not utils.is_posix, "Requires a POSIX os"),
('windows', not utils.is_windows, "Requires Windows"),
('linux', not utils.is_linux, "Requires Linux"),
('mac', not utils.is_mac, "Requires macOS"),
('not_mac', utils.is_mac, "Skipped on macOS"),
('not_frozen', getattr(sys, 'frozen', False),
"Can't be run when frozen"),
('frozen', not getattr(sys, 'frozen', False),
"Can only run when frozen"),
('ci', not ON_CI, "Only runs on CI."),
('no_ci', ON_CI, "Skipped on CI."),
('issue2478', utils.is_windows and config.webengine,
"Broken with QtWebEngine on Windows"),
('issue3572',
(qtutils.version_check('5.10', compiled=False, exact=True) or
qtutils.version_check('5.10.1', compiled=False, exact=True)) and
config.webengine and 'TRAVIS' in os.environ,
"Broken with QtWebEngine with Qt 5.10 on Travis"),
('qtbug60673',
qtutils.version_check('5.8') and
not qtutils.version_check('5.10') and
config.webengine,
"Broken on webengine due to "
"https://bugreports.qt.io/browse/QTBUG-60673"),
('unicode_locale', sys.getfilesystemencoding() == 'ascii',
"Skipped because of ASCII locale"),
('qtwebkit6021_skip',
version.qWebKitVersion and
version.qWebKitVersion() == '602.1',
"Broken on WebKit 602.1")
]
for searched_marker, condition, default_reason in markers:
marker = item.get_closest_marker(searched_marker)
if not marker or not condition:
continue
if 'reason' in marker.kwargs:
reason = '{}: {}'.format(default_reason, marker.kwargs['reason'])
del marker.kwargs['reason']
else:
reason = default_reason + '.'
skipif_marker = pytest.mark.skipif(condition, *marker.args,
reason=reason, **marker.kwargs)
item.add_marker(skipif_marker)
def _handle_wayland():
assert objects.backend == usertypes.Backend.QtWebEngine, objects.backend
if os.environ.get('QUTE_SKIP_WAYLAND_CHECK'):
return
platform = QApplication.instance().platformName()
if platform not in ['wayland', 'wayland-egl']:
return
has_qt511 = qtutils.version_check('5.11', compiled=False)
if has_qt511 and config.val.qt.force_software_rendering == 'chromium':
return
if qtutils.version_check('5.11.2', compiled=False):
return
buttons = []
text = "<p>You can work around this in one of the following ways:</p>"
if 'DISPLAY' in os.environ:
# XWayland is available, but QT_QPA_PLATFORM=wayland is set
buttons.append(_Button("Force XWayland", 'qt.force_platform', 'xcb'))
text += ("<p><b>Force Qt to use XWayland</b></p>"
"<p>This allows you to use the newer QtWebEngine backend "
"(based on Chromium). "
"This sets the <i>qt.force_platform = 'xcb'</i> option "
"(if you have a <i>config.py</i> file, you'll need to set "
"this manually).</p>")
else:
text += ("<p><b>Set up XWayland</b></p>"
"<p>This allows you to use the newer QtWebEngine backend "
"(based on Chromium). ")
if has_qt511:
buttons.append(_Button("Force software rendering",
'qt.force_software_rendering',
'chromium'))
text += ("<p><b>Forcing software rendering</b></p>"
"<p>This allows you to use the newer QtWebEngine backend "
"(based on Chromium) but could have noticeable performance "
"impact (depending on your hardware). This sets the "
"<i>qt.force_software_rendering = 'chromium'</i> option "
"(if you have a <i>config.py</i> file, you'll need to set "
"this manually).</p>")
_show_dialog(backend=usertypes.Backend.QtWebEngine,
because="you're using Wayland", text=text, buttons=buttons)
def can_use_data_path():
"""Whether the current Qt version can use a customized path.
Qt >= 5.10 understands QTWEBENGINE_DICTIONARIES_PATH which means we don't
need to put them to a fixed root-only folder.
"""
return qtutils.version_check('5.10', compiled=False)
def pytest_collection_modifyitems(config, items):
"""Apply @qtwebengine_* markers; skip unittests with QUTE_BDD_WEBENGINE."""
markers = [
('qtwebengine_todo', 'QtWebEngine TODO', pytest.mark.xfail,
config.webengine),
('qtwebengine_skip', 'Skipped with QtWebEngine', pytest.mark.skipif,
config.webengine),
('qtwebengine_notifications', 'Skipped with QtWebEngine < 5.13',
pytest.mark.skipif, config.webengine
and not qtutils.version_check('5.13')),
('qtwebkit_skip', 'Skipped with QtWebKit', pytest.mark.skipif,
not config.webengine),
('qtwebengine_flaky', 'Flaky with QtWebEngine', pytest.mark.skipif,
config.webengine),
('qtwebengine_mac_xfail', 'Fails on macOS with QtWebEngine',
pytest.mark.xfail, config.webengine and utils.is_mac),
]
for item in items:
for name, prefix, pytest_mark, condition in markers:
marker = item.get_closest_marker(name)
if marker and condition:
if marker.args:
text = '{}: {}'.format(prefix, marker.args[0])
else:
text = prefix
item.add_marker(
pytest_mark(condition, reason=text, **marker.kwargs))
def needs_document_end_workaround(self):
"""Check whether to force @run-at document-end.
This needs to be done on QtWebEngine with Qt 5.12 for known-broken
scripts.
On Qt 5.12, accessing the DOM isn't possible with "@run-at
document-start". It was documented to be impossible before, but seems
to work fine.
However, some scripts do DOM access with "@run-at document-start". Fix
those by forcing them to use document-end instead.
"""
if objects.backend != usertypes.Backend.QtWebEngine:
return False
elif not qtutils.version_check('5.12', compiled=False):
return False
broken_scripts = [
('http://userstyles.org', None),
('https://github.com/ParticleCore', 'Iridium'),
]
return any(
self._matches_id(namespace=namespace, name=name)
for namespace, name in broken_scripts)
def _get_suggested_filename(path):
"""Convert a path we got from chromium to a suggested filename.
Chromium thinks we want to download stuff to ~/Download, so even if we
don't, we get downloads with a suffix like (1) for files existing there.
We simply strip the suffix off via regex.
See https://bugreports.qt.io/browse/QTBUG-56978
"""
filename = os.path.basename(path)
suffix_re = re.compile(
r"""
\ ? # Optional space between filename and suffix
(
# Numerical suffix
\([0-9]+\)
|
# ISO-8601 suffix
# https://cs.chromium.org/chromium/src/base/time/time_to_iso8601.cc
\ -\ \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z
)
(?=\.|$) # Begin of extension, or filename without extension
""", re.VERBOSE)
filename = suffix_re.sub('', filename)
if not qtutils.version_check('5.9', compiled=False):
# https://bugreports.qt.io/browse/QTBUG-58155
filename = urllib.parse.unquote(filename)
# Doing basename a *second* time because there could be a %2F in
# there...
filename = os.path.basename(filename)
return filename
def _open_special_pages(args):
"""Open special notification pages which are only shown once.
Args:
args: The argparse namespace.
"""
if args.basedir is not None:
# With --basedir given, don't open anything.
return
general_sect = configfiles.state['general']
tabbed_browser = objreg.get('tabbed-browser',
scope='window',
window='last-focused')
pages = [
# state, condition, URL
('quickstart-done', True,
'https://www.glimpsebrowser.org/quickstart.html'),
('config-migration-shown',
os.path.exists(
os.path.join(standarddir.config(), 'glimpsebrowser.conf')),
'glimpse://help/configuring.html'),
('webkit-warning-shown', objects.backend == usertypes.Backend.QtWebKit,
'glimpse://warning/webkit'),
('old-qt-warning-shown', not qtutils.version_check('5.9'),
'glimpse://warning/old-qt'),
]
for state, condition, url in pages:
if general_sect.get(state) != '1' and condition:
tabbed_browser.tabopen(QUrl(url), background=False)
general_sect[state] = '1'
def normalize_line(line):
line = line.rstrip('\n')
line = re.sub('boundary="-+(=_glimpse|MultipartBoundary)-[0-9a-zA-Z-]+"',
'boundary="---=_glimpse-UUID"', line)
line = re.sub('^-+(=_glimpse|MultipartBoundary)-[0-9a-zA-Z-]+$',
'-----=_glimpse-UUID', line)
line = re.sub(r'localhost:\d{1,5}', 'localhost:(port)', line)
if line.startswith('Date: '):
line = 'Date: today'
if line.startswith('Content-ID: '):
line = 'Content-ID: 42'
# Depending on Python's mimetypes module/the system's mime files, .js
# files could be either identified as x-javascript or just javascript
line = line.replace('Content-Type: application/x-javascript',
'Content-Type: application/javascript')
# With QtWebKit and newer Werkzeug versions, we also get an encoding
# specified.
line = line.replace('javascript; charset=utf-8', 'javascript')
# Added with Qt 5.11
if (line.startswith('Snapshot-Content-Location: ') and
not qtutils.version_check('5.11', compiled=False)):
line = None
return line
def _on_renderer_process_terminated(self, tab, status, code):
"""Show an error when a renderer process terminated."""
if status == browsertab.TerminationStatus.normal:
return
messages = {
browsertab.TerminationStatus.abnormal:
"Renderer process exited with status {}".format(code),
browsertab.TerminationStatus.crashed:
"Renderer process crashed",
browsertab.TerminationStatus.killed:
"Renderer process was killed",
browsertab.TerminationStatus.unknown:
"Renderer process did not start",
}
msg = messages[status]
def show_error_page(html):
tab.set_html(html)
log.webview.error(msg)
if qtutils.version_check('5.9', compiled=False):
url_string = tab.url(requested=True).toDisplayString()
error_page = jinja.render(
'error.html',
title="Error loading {}".format(url_string),
url=url_string,
error=msg)
QTimer.singleShot(100, lambda: show_error_page(error_page))
else:
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-58698
message.error(msg)
self._remove_tab(tab, crashed=True)
if self.widget.count() == 0:
self.tabopen(QUrl('about:blank'))
def __init__(self, *, win_id, private, parent=None):
if private:
assert not qtutils.is_single_process()
super().__init__(parent)
self.widget = tabwidget.TabWidget(win_id, parent=self)
self._win_id = win_id
self._tab_insert_idx_left = 0
self._tab_insert_idx_right = -1
self.shutting_down = False
self.widget.tabCloseRequested.connect(self.on_tab_close_requested)
self.widget.new_tab_requested.connect(self.tabopen)
self.widget.currentChanged.connect(self._on_current_changed)
self.cur_fullscreen_requested.connect(self.widget.tabBar().maybe_hide)
self.widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-65223
if qtutils.version_check('5.10', compiled=False):
self.cur_load_finished.connect(self._leave_modes_on_load)
else:
self.cur_load_started.connect(self._leave_modes_on_load)
# This init is never used, it is immediately thrown away in the next
# line.
self._undo_stack = collections.deque()
self._update_stack_size()
self._filter = signalfilter.SignalFilter(win_id, self)
self._now_focused = None
self.search_text = None
self.search_options = {}
self._local_marks = {}
self._global_marks = {}
self.default_window_icon = self.widget.window().windowIcon()
self.is_private = private
config.instance.changed.connect(self._on_config_changed)
def init_profile(self):
"""Initialize settings on the given profile."""
self.set_http_headers()
self.set_http_cache_size()
self._set_hardcoded_settings()
if qtutils.version_check('5.8'):
self.set_dictionary_language()
def _handle_key_release(self, e):
"""Ignore repeated key release events going to the website.
WORKAROUND for https://bugreports.qt.io/browse/QTBUG-77208
"""
return (e.isAutoRepeat() and qtutils.version_check('5.10')
and objects.backend == usertypes.Backend.QtWebEngine)
def eventFilter(self, obj, event):
"""Act on ChildAdded events."""
if event.type() == QEvent.ChildAdded:
child = event.child()
log.misc.debug("{} got new child {}, installing filter".format(
obj, child))
assert obj is self._widget
child.installEventFilter(self._filter)
if qtutils.version_check('5.11', compiled=False, exact=True):
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-68076
pass_modes = [
usertypes.KeyMode.command, usertypes.KeyMode.prompt,
usertypes.KeyMode.yesno
]
if modeman.instance(self._win_id).mode not in pass_modes:
tabbed_browser = objreg.get('tabbed-browser',
scope='window',
window=self._win_id)
current_index = tabbed_browser.widget.currentIndex()
try:
widget_index = tabbed_browser.widget.indexOf(
self._widget.parent())
except RuntimeError:
widget_index = -1
if current_index == widget_index:
QTimer.singleShot(0, self._widget.setFocus)
elif event.type() == QEvent.ChildRemoved:
child = event.child()
log.misc.debug("{}: removed child {}".format(obj, child))
return False
def _set_cache_size(self):
"""Set the cache size based on the config."""
size = config.val.content.cache.size
if size is None:
size = 1024 * 1024 * 50 # default from QNetworkDiskCachePrivate
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-59909
if not qtutils.version_check('5.9', compiled=False):
size = 0 # pragma: no cover
self.setMaximumCacheSize(size)
def expose(self, web_tab):
"""Expose the web view if needed.
With QtWebEngine 5.13 on macOS/Windows, searching fails (callback
called with False) when the view isn't exposed.
"""
if qtutils.version_check('5.13') and not utils.is_linux:
web_tab.container.expose()
web_tab.show()
def _get_version_tag(tag):
"""Handle tags like pyqt>=5.3.1 for BDD tests.
This transforms e.g. pyqt>=5.3.1 into an appropriate @pytest.mark.skip
marker, and falls back to pytest-bdd's implementation for all other
casesinto an appropriate @pytest.mark.skip marker, and falls back to
"""
version_re = re.compile(
r"""
(?P<package>qt|pyqt)
(?P<operator>==|>=|!=|<)
(?P<version>\d+\.\d+(\.\d+)?)
""", re.VERBOSE)
match = version_re.fullmatch(tag)
if not match:
return None
package = match.group('package')
version = match.group('version')
if package == 'qt':
op = match.group('operator')
do_skip = {
'==':
not qtutils.version_check(version, exact=True, compiled=False),
'>=': not qtutils.version_check(version, compiled=False),
'<': qtutils.version_check(version, compiled=False),
'!=': qtutils.version_check(version, exact=True, compiled=False),
}
return pytest.mark.skipif(do_skip[op], reason='Needs ' + tag)
elif package == 'pyqt':
operators = {
'==': operator.eq,
'>=': operator.ge,
'!=': operator.ne,
}
op = operators[match.group('operator')]
major, minor, patch = [int(e) for e in version.split('.')]
hex_version = (major << 16) | (minor << 8) | patch
return pytest.mark.skipif(not op(PYQT_VERSION, hex_version),
reason='Needs ' + tag)
else:
raise ValueError("Invalid package {!r}".format(package))
def _check_initiator(self, job):
"""Check whether the initiator of the job should be allowed.
Only the browser itself or glimpse:// pages should access any of those
URLs. The request interceptor further locks down glimpse://settings/set.
Args:
job: QWebEngineUrlRequestJob
Return:
True if the initiator is allowed, False if it was blocked.
"""
try:
initiator = job.initiator()
request_url = job.requestUrl()
except AttributeError:
# Added in Qt 5.11
return True
# https://codereview.qt-project.org/#/c/234849/
is_opaque = initiator == QUrl('null')
target = request_url.scheme(), request_url.host()
if is_opaque and not qtutils.version_check('5.12'):
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-70421
# When we don't register the glimpse:// scheme, all requests are
# flagged as opaque.
return True
if (target == ('glimpse', 'testdata') and is_opaque
and qtutils.version_check('5.12')):
# Allow requests to glimpse://testdata, as this is needed in Qt 5.12
# for all tests to work properly. No glimpse://testdata handler is
# installed outside of tests.
return True
if initiator.isValid() and initiator.scheme() != 'glimpse':
log.misc.warning("Blocking malicious request from {} to {}".format(
initiator.toDisplayString(), request_url.toDisplayString()))
job.fail(QWebEngineUrlRequestJob.RequestDenied)
return False
return True
def _handle_cache_nuking():
"""Nuke the QtWebEngine cache if the Qt version changed.
WORKAROUND for https://bugreports.qt.io/browse/QTBUG-72532
"""
if not configfiles.state.qt_version_changed:
return
# Only nuke the cache in cases where we know there are problems.
# It seems these issues started with Qt 5.12.
# They should be fixed with Qt 5.12.5:
# https://codereview.qt-project.org/c/qt/qtwebengine-chromium/+/265408
affected = (qtutils.version_check('5.12', compiled=False) and not
qtutils.version_check('5.12.5', compiled=False))
if not affected:
return
log.init.info("Qt version changed, nuking QtWebEngine cache")
cache_dir = os.path.join(standarddir.cache(), 'webengine')
if os.path.exists(cache_dir):
shutil.rmtree(cache_dir)
def javaScriptAlert(self, url, js_msg):
"""Override javaScriptAlert to use glimpsebrowser prompts."""
if self._is_shutting_down:
return
escape_msg = qtutils.version_check('5.11', compiled=False)
try:
shared.javascript_alert(
url,
js_msg,
abort_on=[self.loadStarted, self.shutting_down],
escape_msg=escape_msg)
except shared.CallSuper:
super().javaScriptAlert(url, js_msg)
def _generate_pdfjs_script(filename):
"""Generate the script that shows the pdf with pdf.js.
Args:
filename: The name of the file to open.
"""
url = QUrl('glimpse://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 (typeof window.PDFJS !== 'undefined') {
// v1.x
{% if disable_create_object_url %}
window.PDFJS.disableCreateObjectURL = true;
{% endif %}
window.PDFJS.verbosity = window.PDFJS.VERBOSITY_LEVELS.info;
} else {
// v2.x
const options = window.PDFViewerApplicationOptions;
{% if disable_create_object_url %}
options.set('disableCreateObjectURL', true);
{% endif %}
options.set('verbosity', pdfjsLib.VerbosityLevel.INFOS);
}
const viewer = window.PDFView || window.PDFViewerApplication;
viewer.open({{ url }});
});
""").render(
url=javascript.to_js(url.toString(QUrl.FullyEncoded)),
# 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))
def javaScriptPrompt(self, url, js_msg, default):
"""Override javaScriptPrompt to use glimpsebrowser prompts."""
escape_msg = qtutils.version_check('5.11', compiled=False)
if self._is_shutting_down:
return (False, "")
try:
return shared.javascript_prompt(
url,
js_msg,
default,
abort_on=[self.loadStarted, self.shutting_down],
escape_msg=escape_msg)
except shared.CallSuper:
return super().javaScriptPrompt(url, js_msg, default)
def ssl_error_page(request, glimpseproc):
if request.config.webengine and qtutils.version_check('5.9'):
glimpseproc.wait_for(message="Certificate error: *")
time.sleep(0.5) # Wait for error page to appear
content = glimpseproc.get_content().strip()
assert ("ERR_INSECURE_RESPONSE" in content or # Qt <= 5.10
"ERR_CERT_AUTHORITY_INVALID" in content) # Qt 5.11
else:
if not request.config.webengine:
line = glimpseproc.wait_for(message='Error while loading *: SSL '
'handshake failed')
line.expected = True
glimpseproc.wait_for(message="Changing title for idx * to 'Error "
"loading page: *'")
content = glimpseproc.get_content().strip()
assert "Unable to load page" in content
def _accept_cookie(request):
"""Check whether the given cookie should be accepted."""
accept = config.val.content.cookies.accept
if accept == 'all':
return True
elif accept in ['no-3rdparty', 'no-unknown-3rdparty']:
if qtutils.version_check('5.11.3', compiled=False):
third_party = request.thirdParty
else:
# WORKAROUND for https://bugreports.qt.io/browse/QTBUG-71393
third_party = (request.thirdParty
and not request.firstPartyUrl.isEmpty())
return not third_party
elif accept == 'never':
return False
else:
raise utils.Unreachable
def request_blocked(request, glimpseproc, kind):
blocking_set_msg = (
"Blocking malicious request from glimpse://settings/set?* to "
"glimpse://settings/set?*")
blocking_csrf_msg = (
"Blocking malicious request from "
"http://localhost:*/data/misc/glimpsescheme_csrf.html to "
"glimpse://settings/set?*")
blocking_js_msg = (
"[http://localhost:*/data/misc/glimpsescheme_csrf.html:0] Not allowed to "
"load local resource: glimpse://settings/set?*")
webkit_error_invalid = (
"Error while loading glimpse://settings/set?*: Invalid glimpse://settings "
"request")
webkit_error_unsupported = (
"Error while loading glimpse://settings/set?*: Unsupported request type"
)
if request.config.webengine and qtutils.version_check('5.12'):
# On Qt 5.12, we mark glimpse:// as a local scheme, causing most requests
# being blocked by Chromium internally (logging to the JS console).
expected_messages = {
'img': [blocking_js_msg],
'link': [blocking_js_msg],
'redirect': [blocking_set_msg],
'form': [blocking_js_msg],
}
elif request.config.webengine:
expected_messages = {
'img': [blocking_csrf_msg],
'link': [blocking_set_msg],
'redirect': [blocking_set_msg],
'form': [blocking_set_msg],
}
else: # QtWebKit
expected_messages = {
'img': [blocking_csrf_msg],
'link': [blocking_csrf_msg, webkit_error_invalid],
'redirect': [blocking_csrf_msg, webkit_error_invalid],
'form': [webkit_error_unsupported],
}
for pattern in expected_messages[kind]:
msg = glimpseproc.wait_for(message=pattern)
msg.expected = True
def wait_for_load_finished_url(self,
url,
*,
timeout=None,
load_status='success',
after=None):
"""Wait until a URL has finished loading."""
__tracebackhide__ = (
lambda e: e.errisinstance(testprocess.WaitForTimeout))
if timeout is None:
if 'CI' in os.environ:
timeout = 15000
else:
timeout = 5000
qurl = QUrl(url)
if not qurl.isValid():
raise ValueError("Invalid URL {}: {}".format(
url, qurl.errorString()))
if (qurl == QUrl('about:blank')
and not qtutils.version_check('5.10', compiled=False)):
# For some reason, we don't get a LoadStatus.success for
# about:blank sometimes.
# However, if we do this for Qt 5.10, we get general testsuite
# instability as site loads get reported with about:blank...
pattern = "Changing title for idx * to 'about:blank'"
else:
# We really need the same representation that the webview uses in
# its __repr__
url = utils.elide(qurl.toDisplayString(QUrl.EncodeUnicode), 100)
assert url
pattern = re.compile(
r"(load status for <glimpsebrowser\.browser\..* "
r"tab_id=\d+ url='{url}/?'>: LoadStatus\.{load_status}|fetch: "
r"PyQt5\.QtCore\.QUrl\('{url}'\) -> .*)".format(
load_status=re.escape(load_status), url=re.escape(url)))
try:
self.wait_for(message=pattern, timeout=timeout, after=after)
except testprocess.WaitForTimeout:
raise testprocess.WaitForTimeout("Timed out while waiting for {} "
"to be loaded".format(url))
def _is_ready(self, what):
"""Called by _parse_line if loading/focusing is done.
When both are done, emits the 'ready' signal.
"""
if what == 'load':
self._load_ready = True
elif what == 'focus':
self._focus_ready = True
else:
raise ValueError("Invalid value {!r} for 'what'.".format(what))
is_qt_5_12 = qtutils.version_check('5.12', compiled=False)
if ((self._load_ready and self._focus_ready)
or (self._load_ready and is_qt_5_12)):
self._load_ready = False
self._focus_ready = False
self.ready.emit()
def __init__(self, *, tabdata, win_id, private, parent=None):
super().__init__(parent)
self._win_id = win_id
self._tabdata = tabdata
theme_color = self.style().standardPalette().color(QPalette.Base)
if private:
assert webenginesettings.private_profile is not None
profile = webenginesettings.private_profile
assert profile.isOffTheRecord()
else:
profile = webenginesettings.default_profile
page = WebEnginePage(theme_color=theme_color,
profile=profile,
parent=self)
self.setPage(page)
if qtutils.version_check('5.11', compiled=False):
# Set a PseudoLayout as a WORKAROUND for
# https://bugreports.qt.io/browse/QTBUG-68224
# and other related issues.
sip.delete(self.layout())
self._layout = miscwidgets.PseudoLayout(self)
def _update_settings(option):
"""Update global settings when qwebsettings changed."""
global_settings.update_setting(option)
if option in [
'content.headers.user_agent', 'content.headers.accept_language'
]:
default_profile.setter.set_http_headers()
if private_profile:
private_profile.setter.set_http_headers()
elif option == 'content.cache.size':
default_profile.setter.set_http_cache_size()
if private_profile:
private_profile.setter.set_http_cache_size()
elif (option == 'content.cookies.store' and
# https://bugreports.qt.io/browse/QTBUG-58650
qtutils.version_check('5.9', compiled=False)):
default_profile.setter.set_persistent_cookie_policy()
# We're not touching the private profile's cookie policy.
elif option == 'spellcheck.languages':
default_profile.setter.set_dictionary_language()
if private_profile:
private_profile.setter.set_dictionary_language(warn=False)
def test_version_check(monkeypatch, qversion, compiled, pyqt, version, exact,
expected):
"""Test for version_check().
Args:
monkeypatch: The pytest monkeypatch fixture.
qversion: The version to set as fake qVersion().
compiled: The value for QT_VERSION_STR (set compiled=False)
pyqt: The value for PYQT_VERSION_STR (set compiled=False)
version: The version to compare with.
exact: Use exact comparing (==)
expected: The expected result.
"""
monkeypatch.setattr(qtutils, 'qVersion', lambda: qversion)
if compiled is not None:
monkeypatch.setattr(qtutils, 'QT_VERSION_STR', compiled)
monkeypatch.setattr(qtutils, 'PYQT_VERSION_STR', pyqt)
compiled_arg = True
else:
compiled_arg = False
actual = qtutils.version_check(version, exact, compiled=compiled_arg)
assert actual == expected
