Adaptations for Chromium 73

Change-Id: I565d1e327852110a5abebed3388d7cd6986bef06
Reviewed-by: Michal Klocek <michal.klocek@qt.io>

52 files changed, 435 insertions, 359 deletions

diff --git a/src/3rdparty b/src/3rdparty
-Subproject 0aae24c2876d19946ce0d28adc38c3dbed2c654
+Subproject d245970d5e4247e9f348b4a3be4a3a86d09c0b9
diff --git a/src/core/chromium_overrides.cpp b/src/core/chromium_overrides.cpp
index 09058301b..c44d75a42 100644
--- a/src/core/chromium_overrides.cpp
+++ b/src/core/chromium_overrides.cpp
@@ -50,6 +50,7 @@
 #include "ui/base/dragdrop/os_exchange_data_provider_factory.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/platform/platform_event_source.h"
+#include "ui/snapshot/snapshot.h"
 #include "ppapi/buildflags/buildflags.h"
 
 #include <QGuiApplication>
@@ -152,6 +153,53 @@ ActivationClient *GetActivationClient(aura::Window *)
 } // namespace wm
 #endif // defined(USE_AURA) || defined(USE_OZONE)
 
+#if defined(USE_AURA)
+namespace ui {
+
+bool GrabWindowSnapshot(gfx::NativeWindow window,
+                        const gfx::Rect& snapshot_bounds,
+                        gfx::Image* image)
+{
+    NOTIMPLEMENTED();
+    return false;
+}
+
+bool GrabViewSnapshot(gfx::NativeView view,
+                      const gfx::Rect& snapshot_bounds,
+                      gfx::Image* image)
+{
+    NOTIMPLEMENTED();
+    return false;
+}
+
+void GrabWindowSnapshotAndScaleAsync(gfx::NativeWindow window,
+                                     const gfx::Rect& source_rect,
+                                     const gfx::Size& target_size,
+                                     const GrabWindowSnapshotAsyncCallback& callback)
+{
+    NOTIMPLEMENTED();
+    callback.Run(gfx::Image());
+}
+
+void GrabWindowSnapshotAsync(gfx::NativeWindow window,
+                             const gfx::Rect& source_rect,
+                             const GrabWindowSnapshotAsyncCallback& callback)
+{
+    NOTIMPLEMENTED();
+    callback.Run(gfx::Image());
+}
+
+void GrabViewSnapshotAsync(gfx::NativeView view,
+                           const gfx::Rect& source_rect,
+                           const GrabWindowSnapshotAsyncCallback& callback)
+{
+    NOTIMPLEMENTED();
+    callback.Run(gfx::Image());
+}
+
+} // namespace ui
+#endif // defined(USE_AURA)
+
 std::unique_ptr<ui::OSExchangeData::Provider>
 ui::OSExchangeDataProviderFactory::CreateProvider() {
     return nullptr;
diff --git a/src/core/clipboard_qt.cpp b/src/core/clipboard_qt.cpp
index 2b0bbae1d..d7fa225cd 100644
--- a/src/core/clipboard_qt.cpp
+++ b/src/core/clipboard_qt.cpp
@@ -43,6 +43,8 @@
 
 #include "clipboard_qt.h"
 #include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/clipboard_constants.h"
+#include "ui/base/clipboard/clipboard_format_type.h"
 
 #include "type_conversion.h"
 
@@ -81,12 +83,6 @@ using namespace QtWebEngineCore;
 
 namespace {
 
-const char kMimeTypeBitmap[] = "image/bmp";
-const char kMimeTypeMozillaURL[] = "text/x-moz-url";
-const char kMimeTypeWebCustomDataCopy[] = "chromium/x-web-custom-data";
-const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
-const char kMimeTypeWebkitSmartPaste[] = "chromium/x-webkit-paste";
-
 QScopedPointer<QMimeData> uncommittedData;
 QMimeData *getUncommittedData()
 {
@@ -104,104 +100,6 @@ Clipboard* Clipboard::Create() {
     return new ClipboardQt;
 }
 
-Clipboard::FormatType Clipboard::GetFormatType(const std::string& format_string)
-{
-    return FormatType::Deserialize(format_string);
-}
-
-const Clipboard::FormatType& Clipboard::GetPlainTextFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeText);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType()
-{
-    return GetPlainTextFormatType();
-}
-
-const Clipboard::FormatType& Clipboard::GetUrlFormatType()
-{
-    return GetPlainTextFormatType();
-}
-
-const Clipboard::FormatType& Clipboard::GetUrlWFormatType()
-{
-    return GetPlainTextWFormatType();
-}
-
-const Clipboard::FormatType& Clipboard::GetHtmlFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeHTML);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetRtfFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeRTF);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetBitmapFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeBitmap);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeWebkitSmartPaste);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypeWebCustomData);
-    return *type;
-}
-
-const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType()
-{
-    static base::NoDestructor<FormatType> type(kMimeTypePepperCustomData);
-    return *type;
-}
-
-
-Clipboard::FormatType::FormatType()
-{
-}
-
-Clipboard::FormatType::FormatType(const std::string& format_string)
-    : data_(format_string)
-{
-}
-
-Clipboard::FormatType::~FormatType()
-{
-}
-
-std::string Clipboard::FormatType::Serialize() const
-{
-  return data_;
-}
-
-Clipboard::FormatType Clipboard::FormatType::Deserialize(const std::string& serialization)
-{
-  return FormatType(serialization);
-}
-
-bool Clipboard::FormatType::Equals(const FormatType& other) const
-{
-  return data_ == other.data_;
-}
-
-#if defined(OS_WIN) || defined(USE_AURA)
-bool Clipboard::FormatType::operator<(const FormatType& other) const
-{
-    return data_.compare(other.data_) < 0;
-}
-#endif
-
 } // namespace ui
 
 namespace QtWebEngineCore {
@@ -240,12 +138,12 @@ void ClipboardQt::WriteHTML(const char* markup_data, size_t markup_len, const ch
 
 void ClipboardQt::WriteRTF(const char* rtf_data, size_t data_len)
 {
-    getUncommittedData()->setData(QString::fromLatin1(kMimeTypeRTF), QByteArray(rtf_data, data_len));
+    getUncommittedData()->setData(QString::fromLatin1(ui::kMimeTypeRTF), QByteArray(rtf_data, data_len));
 }
 
 void ClipboardQt::WriteWebSmartPaste()
 {
-    getUncommittedData()->setData(QString::fromLatin1(kMimeTypeWebkitSmartPaste), QByteArray());
+    getUncommittedData()->setData(QString::fromLatin1(ui::kMimeTypeWebkitSmartPaste), QByteArray());
 }
 
 void ClipboardQt::WriteBitmap(const SkBitmap& bitmap)
@@ -264,15 +162,15 @@ void ClipboardQt::WriteBookmark(const char* title_data, size_t title_len, const
     data.append(reinterpret_cast<const char*>(url.utf16()), url.size() * 2);
     data.append('\n');
     data.append(reinterpret_cast<const char*>(title.utf16()), title.size() * 2);
-    getUncommittedData()->setData(QString::fromLatin1(kMimeTypeMozillaURL), data);
+    getUncommittedData()->setData(QString::fromLatin1(ui::kMimeTypeMozillaURL), data);
 }
 
-void ClipboardQt::WriteData(const FormatType& format, const char* data_data, size_t data_len)
+void ClipboardQt::WriteData(const ui::ClipboardFormatType& format, const char* data_data, size_t data_len)
 {
     getUncommittedData()->setData(QString::fromStdString(format.ToString()), QByteArray(data_data, data_len));
 }
 
-bool ClipboardQt::IsFormatAvailable(const ui::Clipboard::FormatType& format, ui::ClipboardType type) const
+bool ClipboardQt::IsFormatAvailable(const ui::ClipboardFormatType& format, ui::ClipboardType type) const
 {
     const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData(type == ui::CLIPBOARD_TYPE_COPY_PASTE ? QClipboard::Clipboard : QClipboard::Selection);
     return mimeData && mimeData->hasFormat(QString::fromStdString(format.ToString()));
@@ -301,7 +199,7 @@ void ClipboardQt::ReadAvailableTypes(ui::ClipboardType type, std::vector<base::s
         types->push_back(toString16(mimeType));
     *contains_filenames = false;
 
-    const QByteArray customData = mimeData->data(QString::fromLatin1(kMimeTypeWebCustomDataCopy));
+    const QByteArray customData = mimeData->data(QString::fromLatin1(ui::kMimeTypeWebCustomData));
     ui::ReadCustomDataTypes(customData.constData(), customData.size(), types);
 }
 
@@ -340,7 +238,7 @@ void ClipboardQt::ReadRTF(ui::ClipboardType type, std::string* result) const
     const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData(type == ui::CLIPBOARD_TYPE_COPY_PASTE ? QClipboard::Clipboard : QClipboard::Selection);
     if (!mimeData)
         return;
-    const QByteArray byteArray = mimeData->data(QString::fromLatin1(kMimeTypeRTF));
+    const QByteArray byteArray = mimeData->data(QString::fromLatin1(ui::kMimeTypeRTF));
     *result = std::string(byteArray.constData(), byteArray.length());
 }
 
@@ -374,7 +272,7 @@ void ClipboardQt::ReadCustomData(ui::ClipboardType clipboard_type, const base::s
     const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData(clipboard_type == ui::CLIPBOARD_TYPE_COPY_PASTE ? QClipboard::Clipboard : QClipboard::Selection);
     if (!mimeData)
         return;
-    const QByteArray customData = mimeData->data(QString::fromLatin1(kMimeTypeWebCustomDataCopy));
+    const QByteArray customData = mimeData->data(QString::fromLatin1(ui::kMimeTypeWebCustomData));
     ui::ReadCustomDataForType(customData.constData(), customData.size(), type, result);
 }
 
@@ -383,7 +281,7 @@ void ClipboardQt::ReadBookmark(base::string16* title, std::string* url) const
     NOTIMPLEMENTED();
 }
 
-void ClipboardQt::ReadData(const FormatType& format, std::string* result) const
+void ClipboardQt::ReadData(const ui::ClipboardFormatType& format, std::string* result) const
 {
     const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData();
     if (!mimeData)
diff --git a/src/core/clipboard_qt.h b/src/core/clipboard_qt.h
index 2089208bf..d5fa35af6 100644
--- a/src/core/clipboard_qt.h
+++ b/src/core/clipboard_qt.h
@@ -66,7 +66,7 @@ private:
 class ClipboardQt : public ui::Clipboard {
 public:
     uint64_t GetSequenceNumber(ui::ClipboardType type) const override;
-    bool IsFormatAvailable(const FormatType& format, ui::ClipboardType type) const override;
+    bool IsFormatAvailable(const ui::ClipboardFormatType& format, ui::ClipboardType type) const override;
     void Clear(ui::ClipboardType type) override;
     void ReadAvailableTypes(ui::ClipboardType type, std::vector<base::string16>* types, bool* contains_filenames) const override;
     void ReadText(ui::ClipboardType type, base::string16* result) const override;
@@ -80,7 +80,7 @@ public:
     SkBitmap ReadImage(ui::ClipboardType type) const override;
     void ReadCustomData(ui::ClipboardType clipboard_type, const base::string16& type, base::string16* result) const override;
     void ReadBookmark(base::string16* title, std::string* url) const override;
-    void ReadData(const FormatType& format, std::string* result) const override;
+    void ReadData(const ui::ClipboardFormatType& format, std::string* result) const override;
 
     void OnPreShutdown() override { }
 
@@ -92,7 +92,7 @@ protected:
     void WriteBookmark(const char* title_data, size_t title_len, const char* url_data, size_t url_len) override;
     void WriteWebSmartPaste() override;
     void WriteBitmap(const SkBitmap& bitmap) override;
-    void WriteData(const FormatType& format, const char* data_data, size_t data_len) override;
+    void WriteData(const ui::ClipboardFormatType& format, const char* data_data, size_t data_len) override;
 };
 
 } // namespace QtWebEngineCore
diff --git a/src/core/common/extensions/extensions_api_provider_qt.cpp b/src/core/common/extensions/extensions_api_provider_qt.cpp
index aa746133e..22154a9d1 100644
--- a/src/core/common/extensions/extensions_api_provider_qt.cpp
+++ b/src/core/common/extensions/extensions_api_provider_qt.cpp
@@ -62,23 +62,19 @@ namespace extensions {
 
 ExtensionsAPIProviderQt::ExtensionsAPIProviderQt()
 {
-
 }
 
 void ExtensionsAPIProviderQt::RegisterManifestHandlers()
 {
-    RegisterCommonManifestHandlers();
 }
 
 void ExtensionsAPIProviderQt::AddAPIFeatures(FeatureProvider *provider)
 {
-    AddCoreAPIFeatures(provider);
     AddQtAPIFeatures(provider);
 }
 
 void ExtensionsAPIProviderQt::AddAPIJSONSources(JSONFeatureProviderSource *json_source)
 {
-    json_source->LoadJSON(IDR_EXTENSION_API_FEATURES);
     json_source->LoadJSON(IDR_CHROME_EXTENSION_API_FEATURES);
 }
 
@@ -99,7 +95,6 @@ base::StringPiece ExtensionsAPIProviderQt::GetAPISchema(const std::string &name)
 
 void ExtensionsAPIProviderQt::RegisterPermissions(PermissionsInfo* permissions_info)
 {
-
 }
 
 }
diff --git a/src/core/common/extensions/extensions_api_provider_qt.h b/src/core/common/extensions/extensions_api_provider_qt.h
index 8b85e5de2..7d8c5f98b 100644
--- a/src/core/common/extensions/extensions_api_provider_qt.h
+++ b/src/core/common/extensions/extensions_api_provider_qt.h
@@ -58,12 +58,10 @@ public:
     bool IsAPISchemaGenerated(const std::string& name) override;
     base::StringPiece GetAPISchema(const std::string& name) override;
 
-
     // Adds feature definitions to the given |provider| of the specified type.
     void AddManifestFeatures(FeatureProvider* provider) override { }
     void AddBehaviorFeatures(FeatureProvider* provider) override { }
 
-
     // Registers permissions for any associated API features.
     void RegisterPermissions(PermissionsInfo* permissions_info) override;
 
diff --git a/src/core/compositor/compositor.cpp b/src/core/compositor/compositor.cpp
index 31fd15961..cc45db9e7 100644
--- a/src/core/compositor/compositor.cpp
+++ b/src/core/compositor/compositor.cpp
@@ -127,10 +127,9 @@ QSGNode *Compositor::updatePaintNode(QSGNode *oldNode, RenderWidgetHostViewQtDel
     }
     m_updatePaintNodeShouldCommit = false;
 
-    if (m_committedFrame.metadata.request_presentation_feedback)
-        m_taskRunner->PostTask(FROM_HERE,
-                               base::BindOnce(&Compositor::sendPresentationFeedback, m_weakPtrFactory.GetWeakPtr(),
-                                              m_committedFrame.metadata.frame_token));
+    gfx::PresentationFeedback dummyFeedback(base::TimeTicks::Now(), base::TimeDelta(), gfx::PresentationFeedback::Flags::kVSync);
+    m_presentations.insert({m_committedFrame.metadata.frame_token, dummyFeedback});
+
     m_resourceTracker->commitResources();
     frameNode->commit(m_pendingFrame, m_committedFrame, m_resourceTracker.get(), viewDelegate);
     m_committedFrame = std::move(m_pendingFrame);
diff --git a/src/core/config/common.pri b/src/core/config/common.pri
index 85940977a..56e6d547a 100644
--- a/src/core/config/common.pri
+++ b/src/core/config/common.pri
@@ -17,6 +17,7 @@ gn_args += \
     enable_web_speech=false \
     enable_widevine=true \
     has_native_accessibility=false \
+    enable_debugallocation=false \
     use_allocator_shim=false \
     use_allocator=\"none\" \
     use_custom_libcxx=false \
@@ -24,8 +25,7 @@ gn_args += \
     toolkit_views=false \
     treat_warnings_as_errors=false \
     safe_browsing_mode=0 \
-    optimize_webui=false \
-    closure_compile=false
+    optimize_webui=false
 
 !win32: gn_args += \
     use_jumbo_build=true \
@@ -55,7 +55,7 @@ qtConfig(webengine-spellchecker) {
 qtConfig(webengine-webrtc) {
     gn_args += enable_webrtc=true
 } else {
-    gn_args += enable_webrtc=false
+    gn_args += enable_webrtc=false audio_processing_in_audio_service_supported=false
 }
 
 qtConfig(webengine-proprietary-codecs): gn_args += proprietary_codecs=true ffmpeg_branding=\"Chrome\"
@@ -86,6 +86,8 @@ CONFIG(release, debug|release) {
 CONFIG(debug, debug|release) {
     gn_args += is_debug=true
     gn_args += use_debug_fission=false
+    # MSVC requires iterator debug to always match and Qt has leaves it default on.
+    msvc: gn_args += enable_iterator_debugging=true
 }
 
 !webcore_debug: gn_args += remove_webcore_debug_symbols=true
@@ -116,5 +118,3 @@ qtConfig(webengine-kerberos) {
 } else {
     gn_args += use_kerberos=false
 }
-
-!msvc: gn_args += enable_iterator_debugging=false
diff --git a/src/core/config/linux.pri b/src/core/config/linux.pri
index 04c9eca89..d04aea140 100644
--- a/src/core/config/linux.pri
+++ b/src/core/config/linux.pri
@@ -15,7 +15,8 @@ gn_args += \
     ozone_auto_platforms=false \
     ozone_platform_headless=false \
     ozone_platform_external=true \
-    ozone_platform=\"qt\"
+    ozone_platform=\"qt\" \
+    ozone_extra_path=\"$$QTWEBENGINE_ROOT/src/core/ozone/ozone_extra.gni\"
 
 qtConfig(webengine-embedded-build) {
     gn_args += is_desktop_linux=false
diff --git a/src/core/content_browser_client_qt.cpp b/src/core/content_browser_client_qt.cpp
index 866f0feba..673ab32e7 100644
--- a/src/core/content_browser_client_qt.cpp
+++ b/src/core/content_browser_client_qt.cpp
@@ -39,8 +39,8 @@
 
 #include "content_browser_client_qt.h"
 
-#include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
+#include "base/optional.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/message_loop/message_loop.h"
 #include "base/task/post_task.h"
@@ -70,11 +70,16 @@
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.mojom.h"
 #include "content/public/common/url_constants.h"
+#include "content/public/common/user_agent.h"
 #include "media/media_buildflags.h"
 #include "extensions/buildflags/buildflags.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "printing/buildflags/buildflags.h"
+#include "qtwebengine/browser/qtwebengine_content_browser_overlay_manifest.h"
+#include "qtwebengine/browser/qtwebengine_content_renderer_overlay_manifest.h"
+#include "qtwebengine/browser/qtwebengine_packaged_service_manifest.h"
+#include "qtwebengine/browser/qtwebengine_renderer_manifest.h"
 #include "net/ssl/client_cert_identity.h"
 #include "net/ssl/client_cert_store.h"
 #include "services/proxy_resolver/proxy_resolver_service.h"
@@ -508,19 +513,18 @@ public:
     }
 
     // blink::mojom::InsecureInputService:
-    void PasswordFieldVisibleInInsecureContext() override
-    { }
-    void AllPasswordFieldsInInsecureContextInvisible() override
-    { }
     void DidEditFieldInInsecureContext() override
     { }
 
 private:
+    WEB_CONTENTS_USER_DATA_KEY_DECL()
     explicit ServiceDriver(content::WebContents* /*web_contents*/) { }
     friend class content::WebContentsUserData<ServiceDriver>;
     mojo::BindingSet<blink::mojom::InsecureInputService> m_insecureInputServiceBindings;
 };
 
+WEB_CONTENTS_USER_DATA_KEY_IMPL(ServiceDriver)
+
 void ContentBrowserClientQt::InitFrameInterfaces()
 {
     m_frameInterfaces = std::make_unique<service_manager::BinderRegistry>();
@@ -539,9 +543,8 @@ void ContentBrowserClientQt::BindInterfaceRequestFromFrame(content::RenderFrameH
         m_frameInterfaces->TryBindInterface(interface_name, &interface_pipe);
 }
 
-void ContentBrowserClientQt::RegisterInProcessServices(StaticServiceMap* services, content::ServiceManagerConnection* connection)
+void ContentBrowserClientQt::RegisterIOThreadServiceHandlers(content::ServiceManagerConnection *connection)
 {
-    Q_UNUSED(services);
     connection->AddServiceRequestHandler(
             "qtwebengine",
             ServiceQt::GetInstance()->CreateServiceQtRequestHandler());
@@ -553,46 +556,41 @@ void ContentBrowserClientQt::RegisterOutOfProcessServices(content::ContentBrowse
             base::BindRepeating(&base::ASCIIToUTF16, "V8 Proxy Resolver");
 }
 
-std::unique_ptr<base::Value> ContentBrowserClientQt::GetServiceManifestOverlay(base::StringPiece name)
+base::Optional<service_manager::Manifest> ContentBrowserClientQt::GetServiceManifestOverlay(base::StringPiece name)
 {
-    ui::ResourceBundle &rb = ui::ResourceBundle::GetSharedInstance();
-    int id = -1;
-    if (name == content::mojom::kPackagedServicesServiceName)
-        id = IDR_QTWEBENGINE_CONTENT_PACKAGED_SERVICES_MANIFEST_OVERLAY;
-    else if (name == content::mojom::kRendererServiceName)
-        id = IDR_QTWEBENGINE_CONTENT_RENDERER_MANIFEST_OVERLAY;
-    else if (name == content::mojom::kBrowserServiceName)
-        id = IDR_QTWEBENGINE_CONTENT_BROWSER_MANIFEST_OVERLAY;
-    if (id == -1)
-        return nullptr;
+    if (name == content::mojom::kBrowserServiceName) {
+        return GetQtWebEngineContentBrowserOverlayManifest();
+    } else if (name == content::mojom::kPackagedServicesServiceName) {
+        service_manager::Manifest overlay;
+        overlay.packaged_services = GetQtWebEnginePackagedServiceManifests();
+        return overlay;
+    } else if (name == content::mojom::kRendererServiceName) {
+        return GetQtWebEngineContentRendererOverlayManifest();
+    }
 
-    base::StringPiece manifest_contents =
-        rb.GetRawDataResourceForScale(id, ui::ScaleFactor::SCALE_FACTOR_NONE);
-    return base::JSONReader::Read(manifest_contents);
+    return base::nullopt;
 }
 
-std::vector<content::ContentBrowserClient::ServiceManifestInfo> ContentBrowserClientQt::GetExtraServiceManifests()
+std::vector<service_manager::Manifest> ContentBrowserClientQt::GetExtraServiceManifests()
 {
-    return std::vector<content::ContentBrowserClient::ServiceManifestInfo>({
-        {"qtwebengine_renderer", IDR_QTWEBENGINE_RENDERER_SERVICE_MANIFEST},
-    });
+    return std::vector<service_manager::Manifest>{GetQtWebEngineRendererManifest()};
 }
 
 bool ContentBrowserClientQt::CanCreateWindow(
-    content::RenderFrameHost* opener,
-    const GURL& opener_url,
-    const GURL& opener_top_level_frame_url,
-    const GURL& source_origin,
-    content::mojom::WindowContainerType container_type,
-    const GURL& target_url,
-    const content::Referrer& referrer,
-    const std::string& frame_name,
-    WindowOpenDisposition disposition,
-    const blink::mojom::WindowFeatures& features,
-    bool user_gesture,
-    bool opener_suppressed,
-    bool* no_javascript_access) {
-
+        content::RenderFrameHost* opener,
+        const GURL& opener_url,
+        const GURL& opener_top_level_frame_url,
+        const url::Origin& source_origin,
+        content::mojom::WindowContainerType container_type,
+        const GURL& target_url,
+        const content::Referrer& referrer,
+        const std::string& frame_name,
+        WindowOpenDisposition disposition,
+        const blink::mojom::WindowFeatures& features,
+        bool user_gesture,
+        bool opener_suppressed,
+        bool* no_javascript_access)
+{
     Q_UNUSED(opener_url);
     Q_UNUSED(opener_top_level_frame_url);
     Q_UNUSED(source_origin);
@@ -784,4 +782,16 @@ bool ContentBrowserClientQt::ShouldUseProcessPerSite(content::BrowserContext* br
     return ContentBrowserClient::ShouldUseProcessPerSite(browser_context, effective_url);
 }
 
+std::string ContentBrowserClientQt::getUserAgent()
+{
+    // Mention the Chromium version we're based on to get passed stupid UA-string-based feature detection (several WebRTC demos need this)
+    return content::BuildUserAgentFromProduct("QtWebEngine/" QTWEBENGINECORE_VERSION_STR " Chrome/" CHROMIUM_VERSION);
+}
+
+std::string ContentBrowserClientQt::GetProduct() const
+{
+    QString productName(qApp->applicationName() % '/' % qApp->applicationVersion());
+    return productName.toStdString();
+}
+
 } // namespace QtWebEngineCore
diff --git a/src/core/content_browser_client_qt.h b/src/core/content_browser_client_qt.h
index 8e4ec3c9b..0b1c134cc 100644
--- a/src/core/content_browser_client_qt.h
+++ b/src/core/content_browser_client_qt.h
@@ -120,24 +120,23 @@ public:
     void BindInterfaceRequestFromFrame(content::RenderFrameHost* render_frame_host,
                                        const std::string& interface_name,
                                        mojo::ScopedMessagePipeHandle interface_pipe) override;
-    void RegisterInProcessServices(StaticServiceMap* services, content::ServiceManagerConnection* connection) override;
+    void RegisterIOThreadServiceHandlers(content::ServiceManagerConnection *connection) override;
     void RegisterOutOfProcessServices(OutOfProcessServiceMap* services) override;
-    std::vector<ServiceManifestInfo> GetExtraServiceManifests() override;
-    std::unique_ptr<base::Value> GetServiceManifestOverlay(base::StringPiece name) override;
-    bool CanCreateWindow(
-        content::RenderFrameHost* opener,
-        const GURL& opener_url,
-        const GURL& opener_top_level_frame_url,
-        const GURL& source_origin,
-        content::mojom::WindowContainerType container_type,
-        const GURL& target_url,
-        const content::Referrer& referrer,
-        const std::string& frame_name,
-        WindowOpenDisposition disposition,
-        const blink::mojom::WindowFeatures& features,
-        bool user_gesture,
-        bool opener_suppressed,
-        bool* no_javascript_access) override;
+    std::vector<service_manager::Manifest> GetExtraServiceManifests() override;
+    base::Optional<service_manager::Manifest> GetServiceManifestOverlay(base::StringPiece name) override;
+    bool CanCreateWindow(content::RenderFrameHost *opener,
+                         const GURL &opener_url,
+                         const GURL &opener_top_level_frame_url,
+                         const url::Origin &source_origin,
+                         content::mojom::WindowContainerType container_type,
+                         const GURL &target_url,
+                         const content::Referrer &referrer,
+                         const std::string &frame_name,
+                         WindowOpenDisposition disposition,
+                         const blink::mojom::WindowFeatures &features,
+                         bool user_gesture,
+                         bool opener_suppressed,
+                         bool *no_javascript_access) override;
     bool ShouldEnableStrictSiteIsolation() override;
 
     bool AllowGetCookie(const GURL& url,
@@ -206,6 +205,11 @@ public:
             const std::string &method,
             const net::HttpRequestHeaders &headers) override;
 
+    static std::string getUserAgent();
+
+    std::string GetUserAgent() const override { return getUserAgent(); }
+    std::string GetProduct() const override;
+
 private:
     void InitFrameInterfaces();
     void AddNetworkHintsMessageFilter(int render_process_id, net::URLRequestContext *context);
diff --git a/src/core/content_client_qt.cpp b/src/core/content_client_qt.cpp
index 3217bc899..8e5fdf06c 100644
--- a/src/core/content_client_qt.cpp
+++ b/src/core/content_client_qt.cpp
@@ -48,7 +48,6 @@
 #include "base/version.h"
 #include "content/public/common/cdm_info.h"
 #include "content/public/common/content_constants.h"
-#include "content/public/common/user_agent.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_codecs.h"
 #include "media/media_buildflags.h"
@@ -415,12 +414,6 @@ void ContentClientQt::AddAdditionalSchemes(Schemes* schemes)
     schemes->standard_schemes.push_back("chrome-extension");
 }
 
-std::string ContentClientQt::getUserAgent()
-{
-    // Mention the Chromium version we're based on to get passed stupid UA-string-based feature detection (several WebRTC demos need this)
-    return content::BuildUserAgentFromProduct("QtWebEngine/" QTWEBENGINECORE_VERSION_STR " Chrome/" CHROMIUM_VERSION);
-}
-
 base::StringPiece ContentClientQt::GetDataResource(int resource_id, ui::ScaleFactor scale_factor) const {
     return ui::ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(resource_id, scale_factor);
 }
@@ -440,10 +433,4 @@ base::string16 ContentClientQt::GetLocalizedString(int message_id) const
     return l10n_util::GetStringUTF16(message_id);
 }
 
-std::string ContentClientQt::GetProduct() const
-{
-    QString productName(qApp->applicationName() % '/' % qApp->applicationVersion());
-    return productName.toStdString();
-}
-
 } // namespace QtWebEngineCore
diff --git a/src/core/content_client_qt.h b/src/core/content_client_qt.h
index bee79986c..1f4ac0b63 100644
--- a/src/core/content_client_qt.h
+++ b/src/core/content_client_qt.h
@@ -49,8 +49,6 @@ namespace QtWebEngineCore {
 
 class ContentClientQt : public content::ContentClient {
 public:
-    static std::string getUserAgent();
-
 #if QT_CONFIG(webengine_pepper_plugins)
     void AddPepperPlugins(std::vector<content::PepperPluginInfo>* plugins) override;
 #endif
@@ -61,9 +59,7 @@ public:
     base::StringPiece GetDataResource(int, ui::ScaleFactor) const override;
     base::RefCountedMemory* GetDataResourceBytes(int resource_id) const override;
     gfx::Image &GetNativeImageNamed(int resource_id) const override;
-    std::string GetUserAgent() const override { return getUserAgent(); }
     base::string16 GetLocalizedString(int message_id) const override;
-    std::string GetProduct() const override;
 };
 
 } // namespace QtWebEngineCore
diff --git a/src/core/content_utility_client_qt.cpp b/src/core/content_utility_client_qt.cpp
index f49fa6386..0b2dbd08e 100644
--- a/src/core/content_utility_client_qt.cpp
+++ b/src/core/content_utility_client_qt.cpp
@@ -39,6 +39,7 @@
 
 #include "content_utility_client_qt.h"
 
+#include "base/bind.h"
 #include "content/public/utility/utility_thread.h"
 #include "services/proxy_resolver/proxy_resolver_service.h"
 
@@ -50,12 +51,41 @@ ContentUtilityClientQt::ContentUtilityClientQt()
 
 ContentUtilityClientQt::~ContentUtilityClientQt() = default;
 
-void ContentUtilityClientQt::RegisterServices(ContentUtilityClient::StaticServiceMap *services)
+namespace {
+
+std::unique_ptr<service_manager::Service> CreateProxyResolverService(service_manager::mojom::ServiceRequest request)
 {
-    service_manager::EmbeddedServiceInfo proxy_resolver_info;
-    proxy_resolver_info.task_runner = content::ChildThread::Get()->GetIOTaskRunner();
-    proxy_resolver_info.factory = base::BindRepeating(&proxy_resolver::ProxyResolverService::CreateService);
-    services->emplace(proxy_resolver::mojom::kProxyResolverServiceName, proxy_resolver_info);
+    return std::make_unique<proxy_resolver::ProxyResolverService>(std::move(request));
+}
+
+using ServiceFactory = base::OnceCallback<std::unique_ptr<service_manager::Service>()>;
+void RunServiceOnIOThread(ServiceFactory factory)
+{
+    base::OnceClosure terminate_process = base::BindOnce(
+                base::IgnoreResult(&base::SequencedTaskRunner::PostTask),
+                base::SequencedTaskRunnerHandle::Get(), FROM_HERE,
+                base::BindOnce([] { content::UtilityThread::Get()->ReleaseProcess(); }));
+    content::ChildThread::Get()->GetIOTaskRunner()->PostTask(
+                FROM_HERE,
+                base::BindOnce(
+                    [](ServiceFactory factory, base::OnceClosure terminate_process) {
+                        service_manager::Service::RunAsyncUntilTermination(
+                                std::move(factory).Run(), std::move(terminate_process));
+                    },
+                    std::move(factory), std::move(terminate_process)));
+}
+
+}  // namespace
+
+bool ContentUtilityClientQt::HandleServiceRequest(const std::string &service_name,
+                                                  service_manager::mojom::ServiceRequest request)
+{
+    if (service_name == proxy_resolver::mojom::kProxyResolverServiceName) {
+        RunServiceOnIOThread(base::BindOnce(&CreateProxyResolverService, std::move(request)));
+        return true;
+    }
+
+    return false;
 }
 
 } // namespace
diff --git a/src/core/content_utility_client_qt.h b/src/core/content_utility_client_qt.h
index 3fb7c97d5..79972adb8 100644
--- a/src/core/content_utility_client_qt.h
+++ b/src/core/content_utility_client_qt.h
@@ -53,7 +53,9 @@ public:
     ~ContentUtilityClientQt() override;
 
     // content::ContentUtilityClient:
-    void RegisterServices(StaticServiceMap *services) override;
+    bool HandleServiceRequest(const std::string &service_name,
+                              service_manager::mojom::ServiceRequest request) override;
+
 };
 
 } // namespace
diff --git a/src/core/core_chromium.pri b/src/core/core_chromium.pri
index f4cb8c9da..f3954a2c9 100644
--- a/src/core/core_chromium.pri
+++ b/src/core/core_chromium.pri
@@ -95,7 +95,6 @@ SOURCES = \
         ozone/gl_surface_qt.cpp \
         ozone/gl_surface_egl_qt.cpp \
         ozone/gl_surface_wgl_qt.cpp \
-        ozone/ozone_platform_qt.cpp \
         ozone/platform_window_qt.cpp \
         ozone/surface_factory_qt.cpp \
         permission_manager_qt.cpp \
@@ -198,7 +197,6 @@ HEADERS = \
         ozone/gl_surface_qt.h \
         ozone/gl_surface_egl_qt.h \
         ozone/gl_surface_wgl_qt.h \
-        ozone/ozone_platform_qt.h \
         ozone/platform_window_qt.h \
         ozone/surface_factory_qt.h \
         permission_manager_qt.h \
diff --git a/src/core/devtools_frontend_qt.cpp b/src/core/devtools_frontend_qt.cpp
index 40e30e008..0977f5afb 100644
--- a/src/core/devtools_frontend_qt.cpp
+++ b/src/core/devtools_frontend_qt.cpp
@@ -212,7 +212,7 @@ DevToolsFrontendQt::DevToolsFrontendQt(QSharedPointer<WebContentsAdapter> webCon
     // We use a separate prefstore than one in ProfileQt, because that one is in-memory only, and this
     // needs to be stored or it will show introduction text on every load.
     if (webContentsAdapter->profileAdapter()->isOffTheRecord())
-        m_prefStore = std::move(scoped_refptr<PersistentPrefStore>(new InMemoryPrefStore()));
+        m_prefStore = scoped_refptr<PersistentPrefStore>(new InMemoryPrefStore());
     else
         CreateJsonPreferences(false);
 
@@ -270,9 +270,10 @@ void DevToolsFrontendQt::ReadyToCommitNavigation(content::NavigationHandle *navi
         if (navigationHandle->GetURL() != GetFrontendURL())
             m_frontendHost.reset(nullptr);
         else
-            m_frontendHost.reset(content::DevToolsFrontendHost::Create(frame,
-                                    base::Bind(&DevToolsFrontendQt::HandleMessageFromDevToolsFrontend,
-                                                base::Unretained(this))));
+            m_frontendHost = content::DevToolsFrontendHost::Create(
+                        frame,
+                        base::Bind(&DevToolsFrontendQt::HandleMessageFromDevToolsFrontend,
+                                   base::Unretained(this)));
     }
 }
 
diff --git a/src/core/download_manager_delegate_qt.cpp b/src/core/download_manager_delegate_qt.cpp
index c8b75a893..a22706b07 100644
--- a/src/core/download_manager_delegate_qt.cpp
+++ b/src/core/download_manager_delegate_qt.cpp
@@ -112,7 +112,7 @@ void DownloadManagerDelegateQt::pauseDownload(quint32 downloadId)
 void DownloadManagerDelegateQt::resumeDownload(quint32 downloadId)
 {
     if (download::DownloadItem *download = findDownloadById(downloadId))
-        download->Resume();
+        download->Resume(/* user_resume */ true);
 }
 
 void DownloadManagerDelegateQt::removeDownload(quint32 downloadId)
diff --git a/src/core/download_manager_delegate_qt.h b/src/core/download_manager_delegate_qt.h
index db965b12d..382c57524 100644
--- a/src/core/download_manager_delegate_qt.h
+++ b/src/core/download_manager_delegate_qt.h
@@ -104,7 +104,7 @@ private:
     void savePackageDownloadCreated(download::DownloadItem *download);
     ProfileAdapter *m_profileAdapter;
 
-    uint64_t m_currentId;
+    uint32_t m_currentId;
     base::WeakPtrFactory<DownloadManagerDelegateQt> m_weakPtrFactory;
     bool m_nextDownloadIsUserRequested;
 
diff --git a/src/core/extensions/component_extension_resource_manager_qt.cpp b/src/core/extensions/component_extension_resource_manager_qt.cpp
index d8326400e..57e35c231 100644
--- a/src/core/extensions/component_extension_resource_manager_qt.cpp
+++ b/src/core/extensions/component_extension_resource_manager_qt.cpp
@@ -80,6 +80,11 @@ bool ComponentExtensionResourceManagerQt::IsComponentExtensionResource(const bas
     return entry != path_to_resource_id_.end();
 }
 
+const ui::TemplateReplacements *ComponentExtensionResourceManagerQt::GetTemplateReplacementsForExtension(const std::string &) const
+{
+    return nullptr;
+}
+
 void ComponentExtensionResourceManagerQt::AddComponentResourceEntries(const GritResourceMap *entries, size_t size)
 {
     for (size_t i = 0; i < size; ++i) {
diff --git a/src/core/extensions/component_extension_resource_manager_qt.h b/src/core/extensions/component_extension_resource_manager_qt.h
index f12edf61e..2d858630f 100644
--- a/src/core/extensions/component_extension_resource_manager_qt.h
+++ b/src/core/extensions/component_extension_resource_manager_qt.h
@@ -63,6 +63,7 @@ public:
     bool IsComponentExtensionResource(const base::FilePath &extension_path,
                                       const base::FilePath &resource_path,
                                       int *resource_id) const override;
+    const ui::TemplateReplacements *GetTemplateReplacementsForExtension(const std::string& extension_id) const override;
 
 private:
     void AddComponentResourceEntries(const GritResourceMap* entries, size_t size);
diff --git a/src/core/extensions/extension_web_contents_observer_qt.cpp b/src/core/extensions/extension_web_contents_observer_qt.cpp
index 1eb2298ca..365f04e46 100644
--- a/src/core/extensions/extension_web_contents_observer_qt.cpp
+++ b/src/core/extensions/extension_web_contents_observer_qt.cpp
@@ -121,4 +121,6 @@ void ExtensionWebContentsObserverQt::RenderFrameCreated(content::RenderFrameHost
         policy->GrantRequestOrigin(process_id, url::Origin::Create(GURL(content::kChromeUIResourcesURL)));
 }
 
+WEB_CONTENTS_USER_DATA_KEY_IMPL(ExtensionWebContentsObserverQt)
+
 } // namespace extensions
diff --git a/src/core/extensions/extension_web_contents_observer_qt.h b/src/core/extensions/extension_web_contents_observer_qt.h
index 043b9d4fa..267a1095c 100644
--- a/src/core/extensions/extension_web_contents_observer_qt.h
+++ b/src/core/extensions/extension_web_contents_observer_qt.h
@@ -67,6 +67,7 @@ public:
 
 private:
     friend class content::WebContentsUserData<ExtensionWebContentsObserverQt>;
+    WEB_CONTENTS_USER_DATA_KEY_DECL()
     DISALLOW_COPY_AND_ASSIGN(ExtensionWebContentsObserverQt);
 };
 
diff --git a/src/core/media_capture_devices_dispatcher.cpp b/src/core/media_capture_devices_dispatcher.cpp
index a0b19cad3..ecc46f244 100644
--- a/src/core/media_capture_devices_dispatcher.cpp
+++ b/src/core/media_capture_devices_dispatcher.cpp
@@ -59,7 +59,6 @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/origin_util.h"
-#include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_manager_base.h"
 #include "ui/base/l10n/l10n_util.h"
@@ -74,13 +73,12 @@
 namespace QtWebEngineCore {
 
 using content::BrowserThread;
-using content::MediaStreamDevices;
 
 namespace {
 
-const content::MediaStreamDevice *findDeviceWithId(const content::MediaStreamDevices &devices, const std::string &deviceId)
+const blink::MediaStreamDevice *findDeviceWithId(const blink::MediaStreamDevices &devices, const std::string &deviceId)
 {
-    content::MediaStreamDevices::const_iterator iter = devices.begin();
+    blink::MediaStreamDevices::const_iterator iter = devices.begin();
     for (; iter != devices.end(); ++iter) {
         if (iter->id == deviceId) {
             return &(*iter);
@@ -90,21 +88,21 @@ const content::MediaStreamDevice *findDeviceWithId(const content::MediaStreamDev
 }
 
 // Based on chrome/browser/media/desktop_capture_access_handler.cc:
-void getDevicesForDesktopCapture(content::MediaStreamDevices *devices, content::DesktopMediaID mediaId, bool captureAudio)
+void getDevicesForDesktopCapture(blink::MediaStreamDevices *devices, content::DesktopMediaID mediaId, bool captureAudio)
 {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     // Add selected desktop source to the list.
-    devices->push_back(content::MediaStreamDevice(content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE, mediaId.ToString(), "Screen"));
+    devices->push_back(blink::MediaStreamDevice(blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE, mediaId.ToString(), "Screen"));
     if (captureAudio) {
         if (mediaId.type == content::DesktopMediaID::TYPE_WEB_CONTENTS) {
             devices->push_back(
-                    content::MediaStreamDevice(content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE,
-                                               mediaId.ToString(), "Tab audio"));
+                    blink::MediaStreamDevice(blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE,
+                                             mediaId.ToString(), "Tab audio"));
         } else {
             // Use the special loopback device ID for system audio capture.
-            devices->push_back(content::MediaStreamDevice(
-                    content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE,
+            devices->push_back(blink::MediaStreamDevice(
+                    blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE,
                     media::AudioDeviceDescription::kLoopbackInputDeviceId,
                     "System Audio"));
         }
@@ -155,14 +153,14 @@ WebContentsAdapterClient::MediaRequestFlags mediaRequestFlagsForRequest(const co
 {
     WebContentsAdapterClient::MediaRequestFlags requestFlags = WebContentsAdapterClient::MediaNone;
 
-    if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE)
+    if (request.audio_type == blink::MEDIA_DEVICE_AUDIO_CAPTURE)
         requestFlags |= WebContentsAdapterClient::MediaAudioCapture;
-    else if (request.audio_type == content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE)
+    else if (request.audio_type == blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE)
         requestFlags |= WebContentsAdapterClient::MediaDesktopAudioCapture;
 
-    if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE)
+    if (request.video_type == blink::MEDIA_DEVICE_VIDEO_CAPTURE)
         requestFlags |= WebContentsAdapterClient::MediaVideoCapture;
-    else if (request.video_type == content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE)
+    else if (request.video_type == blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE)
         requestFlags |= WebContentsAdapterClient::MediaDesktopVideoCapture;
 
     return requestFlags;
@@ -185,7 +183,7 @@ void MediaCaptureDevicesDispatcher::handleMediaAccessPermissionResponse(content:
 {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    content::MediaStreamDevices devices;
+    blink::MediaStreamDevices devices;
     auto it = m_pendingRequests.find(webContents);
     if (it == m_pendingRequests.end() || it->second.empty())
         return;
@@ -212,11 +210,12 @@ void MediaCaptureDevicesDispatcher::handleMediaAccessPermissionResponse(content:
     if (securityOriginsMatch) {
         if (microphoneRequested || webcamRequested) {
             switch (request.request_type) {
-            case content::MEDIA_OPEN_DEVICE_PEPPER_ONLY:
+            case blink::MEDIA_OPEN_DEVICE_PEPPER_ONLY:
                 getDefaultDevices("", "", microphoneRequested, webcamRequested, &devices);
                 break;
-            case content::MEDIA_DEVICE_ACCESS:
-            case content::MEDIA_GENERATE_STREAM:
+            case blink::MEDIA_DEVICE_ACCESS:
+            case blink::MEDIA_DEVICE_UPDATE:
+            case blink::MEDIA_GENERATE_STREAM:
                 getDefaultDevices(request.requested_audio_device_id, request.requested_video_device_id,
                                   microphoneRequested, webcamRequested, &devices);
                 break;
@@ -238,7 +237,7 @@ void MediaCaptureDevicesDispatcher::handleMediaAccessPermissionResponse(content:
                                                 base::Unretained(this), webContents));
     }
 
-    std::move(callback).Run(devices, devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE : content::MEDIA_DEVICE_OK,
+    std::move(callback).Run(devices, devices.empty() ? blink::MEDIA_DEVICE_INVALID_STATE : blink::MEDIA_DEVICE_OK,
                             std::unique_ptr<content::MediaStreamUI>());
 }
 
@@ -276,17 +275,17 @@ void MediaCaptureDevicesDispatcher::processMediaAccessRequest(WebContentsAdapter
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     // Let's not support tab capture for now.
-    if (request.video_type == content::MEDIA_GUM_TAB_VIDEO_CAPTURE || request.audio_type == content::MEDIA_GUM_TAB_AUDIO_CAPTURE) {
-        std::move(callback).Run(content::MediaStreamDevices(), content::MEDIA_DEVICE_NOT_SUPPORTED, std::unique_ptr<content::MediaStreamUI>());
+    if (request.video_type == blink::MEDIA_GUM_TAB_VIDEO_CAPTURE || request.audio_type == blink::MEDIA_GUM_TAB_AUDIO_CAPTURE) {
+        std::move(callback).Run(blink::MediaStreamDevices(), blink::MEDIA_DEVICE_NOT_SUPPORTED, std::unique_ptr<content::MediaStreamUI>());
         return;
     }
 
-    if (request.video_type == content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE || request.audio_type == content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE) {
+    if (request.video_type == blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE || request.audio_type == blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE) {
         const bool screenCaptureEnabled =
                 adapterClient->webEngineSettings()->testAttribute(WebEngineSettings::ScreenCaptureEnabled);
         const bool originIsSecure = content::IsOriginSecure(request.security_origin);
         if (!screenCaptureEnabled || !originIsSecure) {
-            std::move(callback).Run(content::MediaStreamDevices(), content::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
+            std::move(callback).Run(blink::MediaStreamDevices(), blink::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
             return;
         }
 
@@ -304,10 +303,10 @@ void MediaCaptureDevicesDispatcher::processMediaAccessRequest(WebContentsAdapter
 
 void MediaCaptureDevicesDispatcher::processDesktopCaptureAccessRequest(content::WebContents *webContents, const content::MediaStreamRequest &request, content::MediaResponseCallback callback)
 {
-    content::MediaStreamDevices devices;
+    blink::MediaStreamDevices devices;
 
-    if (request.video_type != content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE || request.requested_video_device_id.empty()) {
-        std::move(callback).Run(devices, content::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
+    if (request.video_type != blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE || request.requested_video_device_id.empty()) {
+        std::move(callback).Run(devices, blink::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
         return;
     }
 
@@ -328,16 +327,16 @@ void MediaCaptureDevicesDispatcher::processDesktopCaptureAccessRequest(content::
 
     // Received invalid device id.
     if (mediaId.type == content::DesktopMediaID::TYPE_NONE) {
-        std::move(callback).Run(devices, content::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
+        std::move(callback).Run(devices, blink::MEDIA_DEVICE_INVALID_STATE, std::unique_ptr<content::MediaStreamUI>());
         return;
     }
 
     // Audio is only supported for screen capture streams.
-    bool capture_audio = (mediaId.type == content::DesktopMediaID::TYPE_SCREEN && request.audio_type == content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE);
+    bool capture_audio = (mediaId.type == content::DesktopMediaID::TYPE_SCREEN && request.audio_type == blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE);
 
     getDevicesForDesktopCapture(&devices, mediaId, capture_audio);
 
-    std::move(callback).Run(devices, devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE : content::MEDIA_DEVICE_OK,
+    std::move(callback).Run(devices, devices.empty() ? blink::MEDIA_DEVICE_INVALID_STATE : blink::MEDIA_DEVICE_OK,
                             std::unique_ptr<content::MediaStreamUI>());
 }
 
@@ -367,14 +366,14 @@ void MediaCaptureDevicesDispatcher::ProcessQueuedAccessRequest(content::WebConte
 }
 
 void MediaCaptureDevicesDispatcher::getDefaultDevices(const std::string &audioDeviceId, const std::string &videoDeviceId,
-                                                      bool audio, bool video, content::MediaStreamDevices *devices)
+                                                      bool audio, bool video, blink::MediaStreamDevices *devices)
 {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(audio || video);
 
     if (audio) {
-        const content::MediaStreamDevices &audioDevices = content::MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
-        const content::MediaStreamDevice *device = findDeviceWithId(audioDevices, audioDeviceId);
+        const blink::MediaStreamDevices &audioDevices = content::MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
+        const blink::MediaStreamDevice *device = findDeviceWithId(audioDevices, audioDeviceId);
         if (!device && !audioDevices.empty())
             device = &audioDevices.front();
         if (device)
@@ -382,8 +381,8 @@ void MediaCaptureDevicesDispatcher::getDefaultDevices(const std::string &audioDe
     }
 
     if (video) {
-        const content::MediaStreamDevices &videoDevices = content::MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
-        const content::MediaStreamDevice *device = findDeviceWithId(videoDevices, videoDeviceId);
+        const blink::MediaStreamDevices &videoDevices = content::MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
+        const blink::MediaStreamDevice *device = findDeviceWithId(videoDevices, videoDeviceId);
         if (!device && !videoDevices.empty())
             device = &videoDevices.front();
         if (device)
@@ -391,7 +390,7 @@ void MediaCaptureDevicesDispatcher::getDefaultDevices(const std::string &audioDe
     }
 }
 
-void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(int render_process_id, int render_frame_id, int page_request_id, const GURL &security_origin, content::MediaStreamType stream_type, content::MediaRequestState state)
+void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(int render_process_id, int render_frame_id, int page_request_id, const GURL &security_origin, blink::MediaStreamType stream_type, content::MediaRequestState state)
 {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI},
@@ -404,7 +403,7 @@ void MediaCaptureDevicesDispatcher::updateMediaRequestStateOnUIThread(int render
                                                                       int render_frame_id,
                                                                       int page_request_id,
                                                                       const GURL & /*security_origin*/,
-                                                                      content::MediaStreamType /*stream_type*/,
+                                                                      blink::MediaStreamType /*stream_type*/,
                                                                       content::MediaRequestState state)
 {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
diff --git a/src/core/media_capture_devices_dispatcher.h b/src/core/media_capture_devices_dispatcher.h
index cc6e60ede..07afd54bf 100644
--- a/src/core/media_capture_devices_dispatcher.h
+++ b/src/core/media_capture_devices_dispatcher.h
@@ -55,7 +55,6 @@
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_delegate.h"
-#include "content/public/common/media_stream_request.h"
 
 namespace QtWebEngineCore {
 
@@ -73,7 +72,7 @@ public:
     void handleMediaAccessPermissionResponse(content::WebContents *, const QUrl &securityOrigin, WebContentsAdapterClient::MediaRequestFlags);
 
 private:
-    void getDefaultDevices(const std::string &audioDeviceId, const std::string &videoDeviceId, bool audio, bool video, content::MediaStreamDevices *);
+    void getDefaultDevices(const std::string &audioDeviceId, const std::string &videoDeviceId, bool audio, bool video, blink::MediaStreamDevices *);
 
     // Overridden from content::MediaObserver:
     void OnAudioCaptureDevicesChanged() override {}
@@ -82,20 +81,20 @@ private:
                                     int render_frame_id,
                                     int page_request_id,
                                     const GURL &security_origin,
-                                    content::MediaStreamType stream_type,
+                                    blink::MediaStreamType stream_type,
                                     content::MediaRequestState state) override;
 
     void OnCreatingAudioStream(int /*render_process_id*/, int /*render_frame_id*/) override {}
     void OnSetCapturingLinkSecured(int /*render_process_id*/,
                                    int /*render_frame_id*/,
                                    int /*page_request_id*/,
-                                   content::MediaStreamType /*stream_type*/,
+                                   blink::MediaStreamType /*stream_type*/,
                                    bool /*is_secure*/) override {}
 
     friend struct base::DefaultSingletonTraits<MediaCaptureDevicesDispatcher>;
 
-    typedef base::RepeatingCallback<void(const content::MediaStreamDevices &devices,
-                                         content::MediaStreamRequestResult result,
+    typedef base::RepeatingCallback<void(const blink::MediaStreamDevices &devices,
+                                         blink::MediaStreamRequestResult result,
                                          std::unique_ptr<content::MediaStreamUI> ui)>
             RepeatingMediaResponseCallback;
 
@@ -121,7 +120,8 @@ private:
     void ProcessQueuedAccessRequest(content::WebContents *);
 
     // Called by the MediaObserver() functions, executed on UI thread.
-    void updateMediaRequestStateOnUIThread(int render_process_id, int render_frame_id, int page_request_id, const GURL &security_origin, content::MediaStreamType stream_type, content::MediaRequestState state);
+    void updateMediaRequestStateOnUIThread(int render_process_id, int render_frame_id, int page_request_id, const GURL &security_origin,
+                                           blink::MediaStreamType stream_type, content::MediaRequestState state);
 
     RequestsQueues m_pendingRequests;
 
diff --git a/src/core/ozone/BUILD.gn b/src/core/ozone/BUILD.gn
new file mode 100644
index 000000000..b96d8a47a
--- /dev/null
+++ b/src/core/ozone/BUILD.gn
@@ -0,0 +1,25 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+source_set("qt") {
+  sources = [
+    "ozone_platform_qt.h",
+    "ozone_platform_qt.cpp",
+  ]
+
+  import("//ui/base/ui_features.gni")
+  import("//ui/gl/features.gni")
+
+  deps = [
+    "//base",
+    "//ui/ozone:ozone_base",
+    "//ui/ozone/common",
+  ]
+
+  defines = [ "OZONE_IMPLEMENTATION" ]
+
+  if (is_linux && !is_desktop_linux) {
+    deps += [ "//ui/events/ozone:events_ozone_evdev"]
+  }
+}
diff --git a/src/core/ozone/ozone_extra.gni b/src/core/ozone/ozone_extra.gni
new file mode 100644
index 000000000..a832f741a
--- /dev/null
+++ b/src/core/ozone/ozone_extra.gni
@@ -0,0 +1,19 @@
+# Copyright 2016 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# This list contains the name of external platforms that are passed to the
+# --ozone-platform command line argument or used for the ozone_platform build
+# config. For example ozone_external_platforms = [ "foo1", "foo2", ... ]
+ozone_external_platforms = [ "qt" ]
+
+# This list contains dependencies for external platforms. Typically, the Ozone
+# implementations are placed into ui/ozone/platform/ and so this will look
+# something like:
+# ozone_external_platform_deps = [ "platform/foo1", "platform/foo_2", ... ]
+ozone_external_platform_deps = []
+
+# If a platform has unit tests, the corresponding source_set can be listed here
+# so that they get included into ozone_unittests.
+# ozone_external_platform_test_deps = [ "platform/foo1:foo1_unitests", ... ]
+ozone_external_platform_test_deps = []
diff --git a/src/core/ozone/ozone_platform_qt.cpp b/src/core/ozone/ozone_platform_qt.cpp
index 1115f3fac..eb7610c0f 100644
--- a/src/core/ozone/ozone_platform_qt.cpp
+++ b/src/core/ozone/ozone_platform_qt.cpp
@@ -37,11 +37,9 @@
 **
 ****************************************************************************/
 
-#include "ozone/ozone_platform_qt.h"
+#include "ozone_platform_qt.h"
 
 #if defined(USE_OZONE)
-#include "ozone/surface_factory_qt.h"
-#include "ozone/platform_window_qt.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/events/system_input_injector.h"
 #include "ui/ozone/common/stub_client_native_pixmap_factory.h"
@@ -54,6 +52,9 @@
 #include "ui/platform_window/platform_window_init_properties.h"
 #include "ui/platform_window/platform_window.h"
 
+#include "surface_factory_qt.h"
+#include "platform_window_qt.h"
+
 namespace ui {
 
 namespace {
diff --git a/src/core/ozone/surface_factory_qt.cpp b/src/core/ozone/surface_factory_qt.cpp
index 9570852c9..5420b4809 100644
--- a/src/core/ozone/surface_factory_qt.cpp
+++ b/src/core/ozone/surface_factory_qt.cpp
@@ -38,10 +38,9 @@
 ****************************************************************************/
 
 #include "surface_factory_qt.h"
-#include "qtwebenginecoreglobal_p.h"
 #include "gl_context_qt.h"
 #include "gl_ozone_egl_qt.h"
-#if QT_CONFIG(webengine_system_x11)
+#if defined(USE_GLX)
 #include "gl_ozone_glx_qt.h"
 #endif
 
@@ -58,7 +57,7 @@ namespace QtWebEngineCore {
 SurfaceFactoryQt::SurfaceFactoryQt()
 {
     Q_ASSERT(qApp);
-#if QT_CONFIG(webengine_system_x11)
+#if defined(USE_GLX)
     if (GLContextHelper::getGlXConfig()) {
         m_impl = gl::kGLImplementationDesktopGL;
         m_ozone.reset(new ui::GLOzoneGLXQt());
diff --git a/src/core/permission_manager_qt.cpp b/src/core/permission_manager_qt.cpp
index 2a7311187..be4d6e598 100644
--- a/src/core/permission_manager_qt.cpp
+++ b/src/core/permission_manager_qt.cpp
@@ -61,6 +61,10 @@ ProfileAdapter::PermissionType toQt(content::PermissionType type)
         return ProfileAdapter::AudioCapturePermission;
     case content::PermissionType::VIDEO_CAPTURE:
         return ProfileAdapter::VideoCapturePermission;
+    case content::PermissionType::CLIPBOARD_READ:
+        return ProfileAdapter::ClipboardRead;
+    case content::PermissionType::CLIPBOARD_WRITE:
+        return ProfileAdapter::ClipboardWrite;
     case content::PermissionType::NOTIFICATIONS:
         return ProfileAdapter::NotificationPermission;
     case content::PermissionType::FLASH:
@@ -71,14 +75,11 @@ ProfileAdapter::PermissionType toQt(content::PermissionType type)
     case content::PermissionType::BACKGROUND_SYNC:
     case content::PermissionType::SENSORS:
     case content::PermissionType::ACCESSIBILITY_EVENTS:
-        break;
-    case content::PermissionType::CLIPBOARD_READ:
-        return ProfileAdapter::ClipboardRead;
-    case content::PermissionType::CLIPBOARD_WRITE:
-        return ProfileAdapter::ClipboardWrite;
     case content::PermissionType::PAYMENT_HANDLER:
     case content::PermissionType::BACKGROUND_FETCH:
+    case content::PermissionType::IDLE_DETECTION:
     case content::PermissionType::NUM:
+        NOTIMPLEMENTED() << "Unsupported permission type: " << static_cast<int>(type);
         break;
     }
     return ProfileAdapter::UnsupportedPermission;
diff --git a/src/core/printing/print_view_manager_qt.cpp b/src/core/printing/print_view_manager_qt.cpp
index 9c0896d92..2bf11990a 100644
--- a/src/core/printing/print_view_manager_qt.cpp
+++ b/src/core/printing/print_view_manager_qt.cpp
@@ -131,14 +131,15 @@ static base::DictionaryValue *createPrintSettings()
 
     printSettings->SetInteger(printing::kSettingDuplexMode, printing::SIMPLEX);
     printSettings->SetInteger(printing::kSettingCopies, 1);
+    printSettings->SetInteger(printing::kSettingPagesPerSheet, 1);
     printSettings->SetBoolean(printing::kSettingCollate, false);
 //    printSettings->SetBoolean(printing::kSettingGenerateDraftData, false);
     printSettings->SetBoolean(printing::kSettingPreviewModifiable, false);
 
-    printSettings->SetBoolean(printing::kSettingShouldPrintSelectionOnly, false);
-    printSettings->SetBoolean(printing::kSettingShouldPrintBackgrounds, true);
-    printSettings->SetBoolean(printing::kSettingHeaderFooterEnabled, false);
-    printSettings->SetBoolean(printing::kSettingRasterizePdf, false);
+    printSettings->SetKey(printing::kSettingShouldPrintSelectionOnly, base::Value(false));
+    printSettings->SetKey(printing::kSettingShouldPrintBackgrounds, base::Value(true));
+    printSettings->SetKey(printing::kSettingHeaderFooterEnabled, base::Value(false));
+    printSettings->SetKey(printing::kSettingRasterizePdf, base::Value(false));
     printSettings->SetInteger(printing::kSettingScaleFactor, 100);
     printSettings->SetString(printing::kSettingDeviceName, "");
     printSettings->SetInteger(printing::kPreviewUIID, 12345678);
@@ -434,4 +435,6 @@ void PrintViewManagerQt::PrintPreviewDone() {
     m_printPreviewRfh = nullptr;
 }
 
+WEB_CONTENTS_USER_DATA_KEY_IMPL(PrintViewManagerQt)
+
 } // namespace QtWebEngineCore
diff --git a/src/core/printing/print_view_manager_qt.h b/src/core/printing/print_view_manager_qt.h
index b21389691..20b988200 100644
--- a/src/core/printing/print_view_manager_qt.h
+++ b/src/core/printing/print_view_manager_qt.h
@@ -137,6 +137,7 @@ private:
     void PrintPreviewDone();
 
 private:
+    WEB_CONTENTS_USER_DATA_KEY_DECL()
     content::RenderFrameHost *m_printPreviewRfh;
     base::FilePath m_pdfOutputPath;
     PrintToPDFCallback m_pdfPrintCallback;
diff --git a/src/core/printing/printing_message_filter_qt.cpp b/src/core/printing/printing_message_filter_qt.cpp
index db59a0807..d1e86343f 100644
--- a/src/core/printing/printing_message_filter_qt.cpp
+++ b/src/core/printing/printing_message_filter_qt.cpp
@@ -183,11 +183,9 @@ void PrintingMessageFilterQt::OnScriptedPrintReply(
   }
 }
 
-void PrintingMessageFilterQt::OnUpdatePrintSettings(
-    int document_cookie, const base::DictionaryValue& job_settings,
-    IPC::Message* reply_msg) {
-  std::unique_ptr<base::DictionaryValue> new_settings(job_settings.DeepCopy());
-
+void PrintingMessageFilterQt::OnUpdatePrintSettings(int document_cookie,
+                                                    base::Value job_settings,
+                                                    IPC::Message* reply_msg) {
   scoped_refptr<printing::PrinterQuery> printer_query;
   printer_query = queue_->PopPrinterQuery(document_cookie);
   if (!printer_query.get()) {
@@ -195,7 +193,7 @@ void PrintingMessageFilterQt::OnUpdatePrintSettings(
         content::ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
   }
   printer_query->SetSettings(
-      std::move(new_settings),
+      std::move(job_settings),
       base::Bind(&PrintingMessageFilterQt::OnUpdatePrintSettingsReply, this,
                  printer_query, reply_msg));
 }
diff --git a/src/core/printing/printing_message_filter_qt.h b/src/core/printing/printing_message_filter_qt.h
index 72e4b43b4..f1a3514c5 100644
--- a/src/core/printing/printing_message_filter_qt.h
+++ b/src/core/printing/printing_message_filter_qt.h
@@ -110,7 +110,7 @@ class PrintingMessageFilterQt : public content::BrowserMessageFilter {
   // handled by the print worker thread and the UI thread. The reply occurs on
   // the IO thread.
   void OnUpdatePrintSettings(int document_cookie,
-                             const base::DictionaryValue& job_settings,
+                             base::Value job_settings,
                              IPC::Message* reply_msg);
   void OnUpdatePrintSettingsReply(scoped_refptr<printing::PrinterQuery> printer_query,
                                   IPC::Message* reply_msg);
diff --git a/src/core/profile_adapter.cpp b/src/core/profile_adapter.cpp
index 6f05c4c3f..a275952e7 100644
--- a/src/core/profile_adapter.cpp
+++ b/src/core/profile_adapter.cpp
@@ -45,7 +45,7 @@
 #include "content/public/browser/download_manager.h"
 
 #include "api/qwebengineurlscheme.h"
-#include "content_client_qt.h"
+#include "content_browser_client_qt.h"
 #include "download_manager_delegate_qt.h"
 #include "net/url_request_context_getter_qt.h"
 #include "permission_manager_qt.h"
@@ -333,7 +333,7 @@ QString ProfileAdapter::httpCachePath() const
 QString ProfileAdapter::httpUserAgent() const
 {
     if (m_httpUserAgent.isNull())
-        return QString::fromStdString(ContentClientQt::getUserAgent());
+        return QString::fromStdString(ContentBrowserClientQt::getUserAgent());
     return m_httpUserAgent;
 }
 
diff --git a/src/core/profile_io_data_qt.cpp b/src/core/profile_io_data_qt.cpp
index 638f949df..467223164 100644
--- a/src/core/profile_io_data_qt.cpp
+++ b/src/core/profile_io_data_qt.cpp
@@ -437,7 +437,7 @@ void ProfileIODataQt::generateCookieStore()
     m_storage->set_cookie_store(std::move(cookieStore));
 
     const std::vector<std::string> cookieableSchemes(kCookieableSchemes,
-                                                     kCookieableSchemes + arraysize(kCookieableSchemes));
+                                                     kCookieableSchemes + base::size(kCookieableSchemes));
     cookieMonster->SetCookieableSchemes(cookieableSchemes);
 }
 
diff --git a/src/core/profile_qt.cpp b/src/core/profile_qt.cpp
index 39500629a..14a39de49 100644
--- a/src/core/profile_qt.cpp
+++ b/src/core/profile_qt.cpp
@@ -53,6 +53,7 @@
 
 #include "base/time/time.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/shared_cors_origin_access_list.h"
 #include "content/public/browser/storage_partition.h"
 
 #include "base/base_paths.h"
@@ -84,8 +85,9 @@
 namespace QtWebEngineCore {
 
 ProfileQt::ProfileQt(ProfileAdapter *profileAdapter)
-    : m_profileIOData(new ProfileIODataQt(this)),
-      m_profileAdapter(profileAdapter)
+    : m_sharedCorsOriginAccessList(content::SharedCorsOriginAccessList::Create())
+    , m_profileIOData(new ProfileIODataQt(this))
+    , m_profileAdapter(profileAdapter)
 #if BUILDFLAG(ENABLE_EXTENSIONS)
     , m_extensionSystem(nullptr)
 #endif // BUILDFLAG(ENABLE_EXTENSIONS)
@@ -116,8 +118,6 @@ ProfileQt::ProfileQt(ProfileAdapter *profileAdapter)
     registry->RegisterDictionaryPref(extensions::pref_names::kInstallLoginScreenAppList);
     registry->RegisterListPref(extensions::pref_names::kAllowedTypes);
     registry->RegisterBooleanPref(extensions::pref_names::kStorageGarbageCollect, false);
-    registry->RegisterInt64Pref(extensions::pref_names::kLastUpdateCheck, 0);
-    registry->RegisterInt64Pref(extensions::pref_names::kNextUpdateCheck, 0);
     registry->RegisterListPref(extensions::pref_names::kAllowedInstallSites);
     registry->RegisterStringPref(extensions::pref_names::kLastChromeVersion, std::string());
     registry->RegisterListPref(extensions::pref_names::kNativeMessagingBlacklist);
@@ -283,6 +283,27 @@ net::URLRequestContextGetter *ProfileQt::CreateRequestContextForStoragePartition
     return nullptr;
 }
 
+content::ClientHintsControllerDelegate *ProfileQt::GetClientHintsControllerDelegate()
+{
+    return nullptr;
+}
+
+void ProfileQt::SetCorsOriginAccessListForOrigin(const url::Origin &source_origin,
+                                                 std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
+                                                 std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
+                                                 base::OnceClosure closure)
+{
+    m_sharedCorsOriginAccessList->SetForOrigin(source_origin,
+                                               std::move(allow_patterns),
+                                               std::move(block_patterns),
+                                               std::move(closure));
+}
+
+const content::SharedCorsOriginAccessList *ProfileQt::GetSharedCorsOriginAccessList() const
+{
+    return m_sharedCorsOriginAccessList.get();
+}
+
 #if QT_CONFIG(webengine_spellchecker)
 void ProfileQt::FailedToLoadDictionary(const std::string &language)
 {
diff --git a/src/core/profile_qt.h b/src/core/profile_qt.h
index a5b37dbd5..5a602f56a 100644
--- a/src/core/profile_qt.h
+++ b/src/core/profile_qt.h
@@ -100,6 +100,12 @@ public:
     content::BackgroundFetchDelegate *GetBackgroundFetchDelegate() override;
     content::BackgroundSyncController *GetBackgroundSyncController() override;
     content::BrowsingDataRemoverDelegate *GetBrowsingDataRemoverDelegate() override;
+    content::ClientHintsControllerDelegate *GetClientHintsControllerDelegate() override;
+    void SetCorsOriginAccessListForOrigin(const url::Origin &source_origin,
+                                          std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
+                                          std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
+                                          base::OnceClosure closure) override;
+    const content::SharedCorsOriginAccessList* GetSharedCorsOriginAccessList() const override;
 
     // Profile implementation:
     PrefService *GetPrefs() override;
@@ -127,6 +133,7 @@ private:
     std::unique_ptr<PermissionManagerQt> m_permissionManager;
     std::unique_ptr<SSLHostStateDelegateQt> m_sslHostStateDelegate;
     std::unique_ptr<PrefService> m_prefService;
+    scoped_refptr<content::SharedCorsOriginAccessList> m_sharedCorsOriginAccessList;
     std::unique_ptr<ProfileIODataQt> m_profileIOData;
     ProfileAdapter *m_profileAdapter;
     friend class ProfileAdapter;
diff --git a/src/core/qtwebengine.gni b/src/core/qtwebengine.gni
index 7c0ca763e..702943261 100644
--- a/src/core/qtwebengine.gni
+++ b/src/core/qtwebengine.gni
@@ -2,6 +2,7 @@ import("//build/config/ui.gni")
 import("//media/media_options.gni")
 import("//extensions/buildflags/buildflags.gni")
 import("//third_party/widevine/cdm/widevine.gni")
+import("//ui/ozone/ozone.gni")
 
 chromium_version = exec_script("//build/util/version.py", [ "-f", rebase_path("//chrome/VERSION"),
                                                             "-t", "@MAJOR@.@MINOR@.@BUILD@.@PATCH@"],
@@ -38,6 +39,7 @@ deps = [
   "//ui/accessibility",
   "//ui/gl",
   "//qtwebengine/browser:interfaces",
+  "//qtwebengine/browser:service_manifests",
   ":qtwebengine_sources",
   ":qtwebengine_resources",
 ]
@@ -46,27 +48,24 @@ if (enable_webrtc) {
   deps += [ "//third_party/webrtc_overrides" ]
 }
 
-if (is_linux && !is_desktop_linux) {
-  deps += [ "//ui/events/ozone:events_ozone_evdev"]
+if (use_ozone) {
+  _ozone_extra_directory = get_path_info(ozone_extra_path, "dir")
+  deps += [ "$_ozone_extra_directory:qt" ]
 }
 
 if (use_xscrnsaver) {
   deps += [ "//ui/base/x" ]
 }
 
-if (use_ozone) {
-  deps += [
-    "//ui/ozone/common"
-  ]
-}
-
 if (enable_extensions) {
   deps += [
     ":qtwebengine_extensions_features"
   ]
 }
 
-data_deps = [ "//qtwebengine/browser:service_manifests" ]
+assert_no_deps = [
+  "//ui/views/mus",
+]
 
 defines = [
   "CHROMIUM_VERSION=\"" + chromium_version[0] + "\""
diff --git a/src/core/qtwebengine_resources.gni b/src/core/qtwebengine_resources.gni
index 283235f66..4df1760da 100644
--- a/src/core/qtwebengine_resources.gni
+++ b/src/core/qtwebengine_resources.gni
@@ -120,7 +120,7 @@ repack("qtwebengine_repack_resources_devtools") {
   ]
   output = "$root_out_dir/qtwebengine_devtools_resources.pak"
   deps = [
-    "//content/browser/devtools:devtools_resources_grit"
+    "//content/browser/devtools:devtools_resources_grit",
   ]
 }
 
diff --git a/src/core/render_widget_host_view_qt.cpp b/src/core/render_widget_host_view_qt.cpp
index 6d3460e0f..39ec14382 100644
--- a/src/core/render_widget_host_view_qt.cpp
+++ b/src/core/render_widget_host_view_qt.cpp
@@ -51,6 +51,8 @@
 #include "web_event_factory.h"
 
 #include "components/viz/common/surfaces/frame_sink_id_allocator.h"
+#include "components/viz/host/host_frame_sink_manager.h"
+#include "content/browser/compositor/surface_utils.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
@@ -279,9 +281,7 @@ RenderWidgetHostViewQt::RenderWidgetHostViewQt(content::RenderWidgetHost *widget
     , m_emptyPreviousSelection(true)
     , m_wheelAckPending(false)
     , m_mouseWheelPhaseHandler(this)
-    // This frame-sink id is based on what RenderWidgetHostViewChildFrame does:
-    , m_frameSinkId(base::checked_cast<uint32_t>(widget->GetProcess()->GetID()),
-                    base::checked_cast<uint32_t>(widget->GetRoutingID()))
+    , m_frameSinkId(host()->GetFrameSinkId())
 {
     host()->SetView(this);
 
@@ -720,7 +720,7 @@ void RenderWidgetHostViewQt::OnUpdateTextInputStateCalled(content::TextInputMana
     ui::TextInputType type = getTextInputType();
     m_delegate->setInputMethodHints(toQtInputMethodHints(getTextInputType()) | Qt::ImhNoPredictiveText | Qt::ImhNoTextHandles | Qt::ImhNoEditMenu);
 
-    m_surroundingText = QString::fromStdString(state->value);
+    m_surroundingText = toQt(state->value);
     // Remove IME composition text from the surrounding text
     if (state->composition_start != -1 && state->composition_end != -1)
         m_surroundingText.remove(state->composition_start, state->composition_end - state->composition_start);
@@ -905,7 +905,7 @@ viz::ScopedSurfaceIdAllocator RenderWidgetHostViewQt::DidUpdateVisualProperties(
 
 void RenderWidgetHostViewQt::OnDidUpdateVisualPropertiesComplete(const cc::RenderFrameMetadata &metadata)
 {
-    synchronizeVisualProperties(metadata.local_surface_allocation_id);
+    synchronizeVisualProperties(metadata.local_surface_id_allocation);
 }
 
 QSGNode *RenderWidgetHostViewQt::updatePaintNode(QSGNode *oldNode)
@@ -1699,7 +1699,7 @@ void RenderWidgetHostViewQt::TakeFallbackContentFrom(content::RenderWidgetHostVi
         SetBackgroundColor(*color);
 }
 
-void RenderWidgetHostViewQt::EnsureSurfaceSynchronizedForLayoutTest()
+void RenderWidgetHostViewQt::EnsureSurfaceSynchronizedForWebTest()
 {
     NOTIMPLEMENTED();
 }
@@ -1711,7 +1711,6 @@ uint32_t RenderWidgetHostViewQt::GetCaptureSequenceNumber() const
 
 void RenderWidgetHostViewQt::ResetFallbackToFirstNavigationSurface()
 {
-    Q_UNIMPLEMENTED();
 }
 
 void RenderWidgetHostViewQt::OnRenderFrameMetadataChangedAfterActivation()
@@ -1726,7 +1725,7 @@ void RenderWidgetHostViewQt::OnRenderFrameMetadataChangedAfterActivation()
     }
 }
 
-void RenderWidgetHostViewQt::synchronizeVisualProperties(const base::Optional<viz::LocalSurfaceId> &childSurfaceId)
+void RenderWidgetHostViewQt::synchronizeVisualProperties(const base::Optional<viz::LocalSurfaceIdAllocation> &childSurfaceId)
 {
     if (childSurfaceId)
         m_localSurfaceIdAllocator.UpdateFromChild(*childSurfaceId);
diff --git a/src/core/render_widget_host_view_qt.h b/src/core/render_widget_host_view_qt.h
index d1f58d445..6e9ddabb9 100644
--- a/src/core/render_widget_host_view_qt.h
+++ b/src/core/render_widget_host_view_qt.h
@@ -46,6 +46,7 @@
 #include "components/viz/common/frame_sinks/begin_frame_source.h"
 #include "components/viz/common/resources/transferable_resource.h"
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
+#include "components/viz/host/host_frame_sink_client.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/renderer_host/input/mouse_wheel_phase_handler.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
@@ -165,7 +166,7 @@ public:
     const viz::FrameSinkId &GetFrameSinkId() const override;
     const viz::LocalSurfaceIdAllocation &GetLocalSurfaceIdAllocation() const override;
     void TakeFallbackContentFrom(content::RenderWidgetHostView *view) override;
-    void EnsureSurfaceSynchronizedForLayoutTest() override;
+    void EnsureSurfaceSynchronizedForWebTest() override;
     uint32_t GetCaptureSequenceNumber() const override;
     void ResetFallbackToFirstNavigationSurface() override;
     void DidStopFlinging() override;
@@ -237,7 +238,7 @@ private:
     void selectionChanged();
     content::RenderFrameHost *getFocusedFrameHost();
 
-    void synchronizeVisualProperties(const base::Optional<viz::LocalSurfaceId> &childSurfaceId);
+    void synchronizeVisualProperties(const base::Optional<viz::LocalSurfaceIdAllocation> &childSurfaceId);
 
     // Geometry of the view in screen DIPs.
     gfx::Rect m_viewRectInDips;
diff --git a/src/core/renderer/content_renderer_client_qt.cpp b/src/core/renderer/content_renderer_client_qt.cpp
index a166186a5..fa1e20f24 100644
--- a/src/core/renderer/content_renderer_client_qt.cpp
+++ b/src/core/renderer/content_renderer_client_qt.cpp
@@ -70,7 +70,6 @@
 #include "net/base/net_errors.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
-#include "services/service_manager/public/cpp/service_context.h"
 #include "third_party/blink/public/platform/web_url_error.h"
 #include "third_party/blink/public/platform/web_url_request.h"
 #include "third_party/blink/public/web/web_security_policy.h"
@@ -238,28 +237,35 @@ bool ContentRendererClientQt::ShouldSuppressErrorPage(content::RenderFrame *fram
 }
 
 // To tap into the chromium localized strings. Ripped from the chrome layer (highly simplified).
-void ContentRendererClientQt::PrepareErrorPage(content::RenderFrame* renderFrame, const blink::WebURLRequest &failedRequest,
+void ContentRendererClientQt::PrepareErrorPage(content::RenderFrame *renderFrame,
                                                const blink::WebURLError &web_error,
+                                               const std::string &httpMethod,
+                                               bool ignoring_cache,
                                                std::string *errorHtml)
 {
-    GetNavigationErrorStringsInternal(renderFrame, failedRequest,
+    Q_UNUSED(ignoring_cache);
+    GetNavigationErrorStringsInternal(renderFrame, httpMethod,
                                       error_page::Error::NetError(web_error.url(), web_error.reason(), web_error.has_copy_in_cache()),
                                       errorHtml);
 }
 
-void ContentRendererClientQt::PrepareErrorPageForHttpStatusError(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
-                                                                 const GURL& unreachable_url, int http_status,
-                                                                 std::string* errorHtml)
+void ContentRendererClientQt::PrepareErrorPageForHttpStatusError(content::RenderFrame *renderFrame,
+                                                                 const GURL &unreachable_url,
+                                                                 const std::string &httpMethod,
+                                                                 bool ignoring_cache,
+                                                                 int http_status,
+                                                                 std::string *errorHtml)
 {
-    GetNavigationErrorStringsInternal(renderFrame, failedRequest,
+    Q_UNUSED(ignoring_cache);
+    GetNavigationErrorStringsInternal(renderFrame, httpMethod,
                                       error_page::Error::HttpError(unreachable_url, http_status),
                                       errorHtml);
 }
 
-void ContentRendererClientQt::GetNavigationErrorStringsInternal(content::RenderFrame *renderFrame, const blink::WebURLRequest &failedRequest, const error_page::Error &error, std::string *errorHtml)
+void ContentRendererClientQt::GetNavigationErrorStringsInternal(content::RenderFrame *renderFrame, const std::string &httpMethod, const error_page::Error &error, std::string *errorHtml)
 {
     Q_UNUSED(renderFrame)
-    const bool isPost = QByteArray::fromStdString(failedRequest.HttpMethod().Utf8()) == QByteArrayLiteral("POST");
+    const bool isPost = QByteArray::fromStdString(httpMethod) == QByteArrayLiteral("POST");
 
     if (errorHtml) {
         // Use a local error page.
@@ -457,8 +463,8 @@ static media::SupportedCodecs GetSupportedCodecs(const std::vector<media::VideoC
             supported_codecs |= media::EME_CODEC_VP8;
             break;
         case media::VideoCodec::kCodecVP9:
-            supported_codecs |= media::EME_CODEC_LEGACY_VP9;
-            supported_codecs |= media::EME_CODEC_VP9;
+            supported_codecs |= media::EME_CODEC_VP9_PROFILE0;
+            supported_codecs |= media::EME_CODEC_VP9_PROFILE2;
             break;
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
         case media::VideoCodec::kCodecH264:
diff --git a/src/core/renderer/content_renderer_client_qt.h b/src/core/renderer/content_renderer_client_qt.h
index 9ec48cb2c..9aebe5bb3 100644
--- a/src/core/renderer/content_renderer_client_qt.h
+++ b/src/core/renderer/content_renderer_client_qt.h
@@ -87,11 +87,17 @@ public:
     bool ShouldSuppressErrorPage(content::RenderFrame *, const GURL &) override;
     bool HasErrorPage(int http_status_code) override;
 
-    void PrepareErrorPage(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
-                          const blink::WebURLError& error, std::string* errorHtml) override;
-    void PrepareErrorPageForHttpStatusError(content::RenderFrame* render_frame, const blink::WebURLRequest& failed_request,
-                                            const GURL& unreachable_url, int http_status,
-                                            std::string* error_html) override;
+    void PrepareErrorPage(content::RenderFrame *render_frame,
+                          const blink::WebURLError &error,
+                          const std::string &http_method,
+                          bool ignoring_cache,
+                          std::string *error_html) override;
+    void PrepareErrorPageForHttpStatusError(content::RenderFrame *render_frame,
+                                            const GURL &unreachable_url,
+                                            const std::string &http_method,
+                                            bool ignoring_cache,
+                                            int http_status,
+                                            std::string *error_html) override;
 
     unsigned long long VisitedLinkHash(const char *canonicalUrl, size_t length) override;
     bool IsLinkVisited(unsigned long long linkHash) override;
@@ -129,7 +135,7 @@ private:
     // service_manager::LocalInterfaceProvider:
     void GetInterface(const std::string& name, mojo::ScopedMessagePipeHandle request_handle) override;
 
-    void GetNavigationErrorStringsInternal(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
+    void GetNavigationErrorStringsInternal(content::RenderFrame* renderFrame, const std::string &httpMethod,
                                            const error_page::Error& error, std::string* errorHtml);
 
     QScopedPointer<visitedlink::VisitedLinkSlave> m_visitedLinkSlave;
diff --git a/src/core/renderer/extensions/resource_request_policy_qt.cpp b/src/core/renderer/extensions/resource_request_policy_qt.cpp
index dc5a90120..a64b1fef8 100644
--- a/src/core/renderer/extensions/resource_request_policy_qt.cpp
+++ b/src/core/renderer/extensions/resource_request_policy_qt.cpp
@@ -50,6 +50,7 @@
 #include "extensions/common/manifest_handlers/web_accessible_resources_info.h"
 #include "extensions/common/manifest_handlers/webview_info.h"
 #include "extensions/renderer/dispatcher.h"
+#include "third_party/blink/public/mojom/devtools/console_message.mojom-shared.h"
 #include "third_party/blink/public/web/web_console_message.h"
 #include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/web_local_frame.h"
@@ -172,7 +173,7 @@ bool ResourceRequestPolicyQt::CanRequestResource(const GURL &resource_url,
                     "web_accessible_resources manifest key in order to be loaded by "
                     "pages outside the extension.",
                     resource_url.spec().c_str());
-        frame->AddMessageToConsole(blink::WebConsoleMessage(blink::WebConsoleMessage::kLevelError, blink::WebString::FromUTF8(message)));
+        frame->AddMessageToConsole(blink::WebConsoleMessage(blink::mojom::ConsoleMessageLevel::kError, blink::WebString::FromUTF8(message)));
         return false;
     }
 
diff --git a/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp b/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
index 9ad59f939..9af05fd08 100644
--- a/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
+++ b/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
@@ -70,6 +70,7 @@
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPoint.h"
+#include "third_party/skia/include/core/SkTextBlob.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/private/SkTemplates.h"
 #include "ui/gfx/geometry/rect.h"
@@ -299,14 +300,12 @@ int32_t PepperFlashRendererHostQt::OnDrawGlyphs(
 
     SkPaint paint;
     paint.setColor(params.color);
-    paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-    paint.setAntiAlias(true);
-    paint.setHinting(SkFontHinting::kFull);
-    paint.setTextSize(SkIntToScalar(params.font_desc.size));
-    paint.setTypeface(std::move(typeface));
+
+    SkFont font(std::move(typeface), SkIntToScalar(params.font_desc.size));
+    font.setHinting(SkFontHinting::kFull);
     if (params.allow_subpixel_aa) {
-        paint.setSubpixelText(true);
-        paint.setLCDRenderText(true);
+        font.setSubpixel(true);
+        font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
     }
 
     SkScalar x = SkIntToScalar(params.position.x);
@@ -315,15 +314,16 @@ int32_t PepperFlashRendererHostQt::OnDrawGlyphs(
     // Build up the skia advances.
     size_t glyph_count = params.glyph_indices.size();
     if (glyph_count) {
-        std::vector<SkPoint> sk_positions(glyph_count);
+        SkTextBlobBuilder builder;
+        auto rec = builder.allocRunPos(font, glyph_count);
+        memcpy(rec.glyphs, &params.glyph_indices[0], glyph_count * 2);
+        SkPoint* pos = reinterpret_cast<SkPoint*>(rec.pos);
         for (uint32_t i = 0; i < glyph_count; i++) {
-            sk_positions[i].set(x, y);
+            pos[i].set(x, y);
             x += SkFloatToScalar(params.glyph_advances[i].x);
             y += SkFloatToScalar(params.glyph_advances[i].y);
         }
-
-        canvas->drawPosText(
-            &params.glyph_indices[0], glyph_count * 2, &sk_positions[0], paint);
+        canvas->drawTextBlob(builder.make(), 0, 0, paint);
     }
 
     if (needs_unmapping)
@@ -351,7 +351,7 @@ int32_t PepperFlashRendererHostQt::OnNavigate(
     std::map<std::string, FlashNavigateUsage>& rejected_headers =
             g_rejected_headers.Get();
     if (rejected_headers.empty()) {
-        for (size_t i = 0; i < arraysize(kRejectedHttpRequestHeaders); ++i)
+        for (size_t i = 0; i < base::size(kRejectedHttpRequestHeaders); ++i)
             rejected_headers[kRejectedHttpRequestHeaders[i]] =
                     static_cast<FlashNavigateUsage>(i);
     }
diff --git a/src/core/renderer/web_channel_ipc_transport.cpp b/src/core/renderer/web_channel_ipc_transport.cpp
index f1da8289a..3b9c17b6a 100644
--- a/src/core/renderer/web_channel_ipc_transport.cpp
+++ b/src/core/renderer/web_channel_ipc_transport.cpp
@@ -119,7 +119,9 @@ void WebChannelTransport::Uninstall(blink::WebLocalFrame *frame, uint worldId)
     if (qtObjectValue.IsEmpty() || !qtObjectValue->IsObject())
         return;
     v8::Local<v8::Object> qtObject = v8::Local<v8::Object>::Cast(qtObjectValue);
-    qtObject->Delete(gin::StringToV8(isolate, "webChannelTransport"));
+    // FIXME: ?
+    auto whocares = qtObject->Delete(context, gin::StringToV8(isolate, "webChannelTransport"));
+    Q_UNUSED(whocares);
 }
 
 void WebChannelTransport::NativeQtSendMessage(gin::Arguments *args)
diff --git a/src/core/web_contents_adapter.cpp b/src/core/web_contents_adapter.cpp
index 535c50a95..90cd598ab 100644
--- a/src/core/web_contents_adapter.cpp
+++ b/src/core/web_contents_adapter.cpp
@@ -91,6 +91,7 @@
 #include "third_party/blink/public/web/web_media_player_action.h"
 #include "printing/buildflags/buildflags.h"
 #include "ui/base/clipboard/clipboard.h"
+#include "ui/base/clipboard/clipboard_constants.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/font_render_params.h"
 
@@ -250,7 +251,7 @@ static std::unique_ptr<content::WebContents> createBlankWebContents(WebContentsA
     return webContents;
 }
 
-static void serializeNavigationHistory(const content::NavigationController &controller, QDataStream &output)
+static void serializeNavigationHistory(content::NavigationController &controller, QDataStream &output)
 {
     const int currentIndex = controller.GetCurrentEntryIndex();
     const int count = controller.GetEntryCount();
@@ -262,7 +263,7 @@ static void serializeNavigationHistory(const content::NavigationController &cont
 
     // Logic taken from SerializedNavigationEntry::WriteToPickle.
     for (int i = 0; i < count; ++i) {
-        const content::NavigationEntry* entry = (i == pendingIndex)
+        content::NavigationEntry* entry = (i == pendingIndex)
             ? controller.GetPendingEntry()
             : controller.GetEntryAtIndex(i);
         if (entry->GetVirtualURL().is_valid()) {
@@ -1365,7 +1366,7 @@ static QMimeData *mimeDataFromDropData(const content::DropData &dropData)
     if (!dropData.custom_data.empty()) {
         base::Pickle pickle;
         ui::WriteCustomDataToPickle(dropData.custom_data, &pickle);
-        mimeData->setData(toQt(ui::Clipboard::GetWebCustomDataFormatType().ToString()), QByteArray((const char*)pickle.data(), pickle.size()));
+        mimeData->setData(QLatin1String(ui::kMimeTypeWebCustomData), QByteArray((const char*)pickle.data(), pickle.size()));
     }
     return mimeData;
 }
@@ -1483,8 +1484,8 @@ static void fillDropDataFromMimeData(content::DropData *dropData, const QMimeDat
         dropData->html = toNullableString16(mimeData->html());
     if (mimeData->hasText())
         dropData->text = toNullableString16(mimeData->text());
-    if (mimeData->hasFormat(toQt(ui::Clipboard::GetWebCustomDataFormatType().ToString()))) {
-        QByteArray customData = mimeData->data(toQt(ui::Clipboard::GetWebCustomDataFormatType().ToString()));
+    if (mimeData->hasFormat(QLatin1String(ui::kMimeTypeWebCustomData))) {
+        QByteArray customData = mimeData->data(QLatin1String(ui::kMimeTypeWebCustomData));
         ui::ReadCustomDataIntoMap(customData.constData(), customData.length(), &dropData->custom_data);
     }
 }
diff --git a/src/core/web_contents_delegate_qt.cpp b/src/core/web_contents_delegate_qt.cpp
index 7c6741723..adc05253d 100644
--- a/src/core/web_contents_delegate_qt.cpp
+++ b/src/core/web_contents_delegate_qt.cpp
@@ -136,6 +136,7 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents
     Q_ASSERT(target);
 
     content::NavigationController::LoadURLParams load_url_params(params.url);
+    load_url_params.initiator_origin = params.initiator_origin;
     load_url_params.source_site_instance = target_site_instance;
     load_url_params.referrer = referrer;
     load_url_params.frame_tree_node_id = params.frame_tree_node_id;
@@ -145,7 +146,11 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents
     load_url_params.should_replace_current_entry = params.should_replace_current_entry;
     load_url_params.is_renderer_initiated = params.is_renderer_initiated;
     load_url_params.started_from_context_menu = params.started_from_context_menu;
+    load_url_params.has_user_gesture = params.user_gesture;
+    load_url_params.blob_url_loader_factory = params.blob_url_loader_factory;
     load_url_params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
+    load_url_params.href_translate = params.href_translate;
+    load_url_params.reload_type = params.reload_type;
     if (params.uses_post) {
         load_url_params.load_type = content::NavigationController::LOAD_TYPE_HTTP_POST;
         load_url_params.post_data = params.post_data;
@@ -155,7 +160,7 @@ content::WebContents *WebContentsDelegateQt::OpenURLFromTab(content::WebContents
     return target;
 }
 
-static bool shouldUseActualURL(const content::NavigationEntry *entry)
+static bool shouldUseActualURL(content::NavigationEntry *entry)
 {
     Q_ASSERT(entry);
 
@@ -415,7 +420,7 @@ void WebContentsDelegateQt::DidUpdateFaviconURL(const std::vector<content::Favic
     m_faviconManager->update(faviconCandidates);
 }
 
-void WebContentsDelegateQt::WebContentsCreated(content::WebContents */*source_contents*/,
+void WebContentsDelegateQt::WebContentsCreated(content::WebContents * /*source_contents*/,
                                                int /*opener_render_process_id*/, int /*opener_render_frame_id*/,
                                                const std::string &/*frame_name*/,
                                                const GURL &target_url, content::WebContents *newContents)
@@ -652,12 +657,12 @@ void WebContentsDelegateQt::BeforeUnloadFired(bool proceed, const base::TimeTick
     Q_UNUSED(proceed_time);
 }
 
-bool WebContentsDelegateQt::CheckMediaAccessPermission(content::RenderFrameHost *, const GURL& security_origin, content::MediaStreamType type)
+bool WebContentsDelegateQt::CheckMediaAccessPermission(content::RenderFrameHost *, const GURL& security_origin, blink::MediaStreamType type)
 {
     switch (type) {
-    case content::MEDIA_DEVICE_AUDIO_CAPTURE:
+    case blink::MEDIA_DEVICE_AUDIO_CAPTURE:
         return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::AudioCapturePermission);
-    case content::MEDIA_DEVICE_VIDEO_CAPTURE:
+    case blink::MEDIA_DEVICE_VIDEO_CAPTURE:
         return m_viewClient->profileAdapter()->checkPermission(toQt(security_origin), ProfileAdapter::VideoCapturePermission);
     default:
         LOG(INFO) << "WebContentsDelegateQt::CheckMediaAccessPermission: "
diff --git a/src/core/web_contents_delegate_qt.h b/src/core/web_contents_delegate_qt.h
index c6bf35c34..ee1bca81f 100644
--- a/src/core/web_contents_delegate_qt.h
+++ b/src/core/web_contents_delegate_qt.h
@@ -126,7 +126,7 @@ public:
     void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
     void RequestToLockMouse(content::WebContents *web_contents, bool user_gesture, bool last_unlocked_by_target) override;
     void BeforeUnloadFired(content::WebContents* tab, bool proceed, bool* proceed_to_fire_unload) override;
-    bool CheckMediaAccessPermission(content::RenderFrameHost* render_frame_host, const GURL& security_origin, content::MediaStreamType type) override;
+    bool CheckMediaAccessPermission(content::RenderFrameHost* render_frame_host, const GURL& security_origin, blink::MediaStreamType type) override;
     void RegisterProtocolHandler(content::WebContents* web_contents, const std::string& protocol, const GURL& url, bool user_gesture) override;
     void UnregisterProtocolHandler(content::WebContents* web_contents, const std::string& protocol, const GURL& url, bool user_gesture) override;
 
diff --git a/src/core/web_engine_context.cpp b/src/core/web_engine_context.cpp
index 01f28da2a..7c6b6669d 100644
--- a/src/core/web_engine_context.cpp
+++ b/src/core/web_engine_context.cpp
@@ -77,8 +77,9 @@
 #include "mojo/core/embedder/embedder.h"
 #include "net/base/port_util.h"
 #include "ppapi/buildflags/buildflags.h"
-#include "services/service_manager/sandbox/switches.h"
+#include "services/network/public/cpp/network_switches.h"
 #include "services/resource_coordinator/public/cpp/resource_coordinator_features.h"
+#include "services/service_manager/sandbox/switches.h"
 #include "ui/events/event_switches.h"
 #include "ui/native_theme/native_theme_features.h"
 #include "ui/gl/gl_switches.h"
@@ -372,7 +373,7 @@ WebEngineContext::WebEngineContext()
 {
     base::TaskScheduler::Create("Browser");
     m_contentRunner.reset(content::ContentMainRunner::Create());
-    m_browserRunner.reset(content::BrowserMainRunner::Create());
+    m_browserRunner = content::BrowserMainRunner::Create();
 
 #ifdef Q_OS_LINUX
     // Call qputenv before BrowserMainRunnerImpl::Initialize is called.
@@ -474,8 +475,12 @@ WebEngineContext::WebEngineContext()
     appendToFeatureSwitch(parsedCommandLine, switches::kEnableFeatures, features::kAllowContentInitiatedDataUrlNavigations.name);
     // Surface synchronization breaks our current graphics integration (since 65)
     appendToFeatureSwitch(parsedCommandLine, switches::kDisableFeatures, features::kEnableSurfaceSynchronization.name);
+    // Viz Display Compositor is enabled by default since 73. Doesn't work for us (also implies SurfaceSynchronization)
+    appendToFeatureSwitch(parsedCommandLine, switches::kDisableFeatures, features::kVizDisplayCompositor.name);
     // The video-capture service is not functioning at this moment (since 69)
     appendToFeatureSwitch(parsedCommandLine, switches::kDisableFeatures, features::kMojoVideoCapture.name);
+    // Breaks WebEngineNewViewRequest.userInitiated API (since 73)
+    appendToFeatureSwitch(parsedCommandLine, switches::kDisableFeatures, features::kUserActivationV2.name);
 
     appendToFeatureSwitch(parsedCommandLine, switches::kDisableFeatures, features::kBackgroundFetch.name);
 
@@ -616,8 +621,8 @@ WebEngineContext::WebEngineContext()
 
     base::ThreadRestrictions::SetIOAllowed(true);
 
-    if (parsedCommandLine->HasSwitch(switches::kExplicitlyAllowedPorts)) {
-        std::string allowedPorts = parsedCommandLine->GetSwitchValueASCII(switches::kExplicitlyAllowedPorts);
+    if (parsedCommandLine->HasSwitch(network::switches::kExplicitlyAllowedPorts)) {
+        std::string allowedPorts = parsedCommandLine->GetSwitchValueASCII(network::switches::kExplicitlyAllowedPorts);
         net::SetExplicitlyAllowedPorts(allowedPorts);
     }
 
diff --git a/src/core/web_engine_context_threads.cpp b/src/core/web_engine_context_threads.cpp
index 07a86cc69..75f8bd470 100644
--- a/src/core/web_engine_context_threads.cpp
+++ b/src/core/web_engine_context_threads.cpp
@@ -53,6 +53,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/renderer/in_process_renderer_thread.h"
 #include "content/utility/in_process_utility_thread.h"
+#include "gpu/ipc/service/gpu_init.h"
 
 #include <memory>