Merge branch '5.15' into dev

Last commits before 87 update.

Change-Id: Id156b0199a8fd354c946cfe604ae8541ba554658

11 files changed, 257 insertions, 232 deletions

diff --git a/src/core/renderer/content_renderer_client_qt.cpp b/src/core/renderer/content_renderer_client_qt.cpp
index 8c70f2e42..154cb36b4 100644
--- a/src/core/renderer/content_renderer_client_qt.cpp
+++ b/src/core/renderer/content_renderer_client_qt.cpp
@@ -83,8 +83,8 @@
 
 #include "common/qt_messages.h"
 #include "renderer/render_frame_observer_qt.h"
-#include "renderer/render_view_observer_qt.h"
-#include "renderer/render_thread_observer_qt.h"
+#include "renderer/web_engine_page_render_frame.h"
+#include "renderer/render_configuration.h"
 #include "renderer/user_resource_controller.h"
 #if QT_CONFIG(webengine_webchannel)
 #include "renderer/web_channel_ipc_transport.h"
@@ -133,12 +133,13 @@ ContentRendererClientQt::~ContentRendererClientQt() {}
 void ContentRendererClientQt::RenderThreadStarted()
 {
     content::RenderThread *renderThread = content::RenderThread::Get();
-    m_renderThreadObserver.reset(new RenderThreadObserverQt());
+    m_renderConfiguration.reset(new RenderConfiguration());
+    m_userResourceController.reset(new UserResourceController());
     m_visitedLinkReader.reset(new visitedlink::VisitedLinkReader);
     m_webCacheImpl.reset(new web_cache::WebCacheImpl());
 
-    renderThread->AddObserver(m_renderThreadObserver.data());
-    renderThread->AddObserver(UserResourceController::instance());
+    renderThread->AddObserver(m_renderConfiguration.data());
+    renderThread->AddObserver(m_userResourceController.data());
 
 #if QT_CONFIG(webengine_spellchecker)
     if (!m_spellCheck)
@@ -187,23 +188,18 @@ void ContentRendererClientQt::ExposeInterfacesToBrowser(mojo::BinderMap* binders
 #endif
 }
 
-void ContentRendererClientQt::RenderViewCreated(content::RenderView *render_view)
-{
-    // RenderViewObservers destroy themselves with their RenderView.
-    new RenderViewObserverQt(render_view);
-    UserResourceController::instance()->renderViewCreated(render_view);
-}
-
 void ContentRendererClientQt::RenderFrameCreated(content::RenderFrame *render_frame)
 {
     QtWebEngineCore::RenderFrameObserverQt *render_frame_observer =
             new QtWebEngineCore::RenderFrameObserverQt(render_frame, m_webCacheImpl.data());
+    if (render_frame->IsMainFrame()) {
 #if QT_CONFIG(webengine_webchannel)
-    if (render_frame->IsMainFrame())
         new WebChannelIPCTransport(render_frame);
 #endif
+        new WebEnginePageRenderFrame(render_frame);
+    }
 
-    UserResourceController::instance()->renderFrameCreated(render_frame);
+    m_userResourceController->renderFrameCreated(render_frame);
 
     new QtWebEngineCore::ContentSettingsObserverQt(render_frame);
 
@@ -234,7 +230,7 @@ void ContentRendererClientQt::RunScriptsAtDocumentEnd(content::RenderFrame *rend
     RenderFrameObserverQt *render_frame_observer = RenderFrameObserverQt::Get(render_frame);
 
     if (render_frame_observer && !render_frame_observer->isFrameDetached())
-        UserResourceController::instance()->RunScriptsAtDocumentEnd(render_frame);
+        m_userResourceController->RunScriptsAtDocumentEnd(render_frame);
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
     ExtensionsRendererClientQt::GetInstance()->RunScriptsAtDocumentEnd(render_frame);
@@ -305,10 +301,11 @@ void ContentRendererClientQt::GetNavigationErrorStringsInternal(content::RenderF
         // NetErrorHelper::GetErrorStringsForDnsProbe, but that one is harder to untangle.
 
         error_page::LocalizedError::PageState errorPageState =
-            error_page::LocalizedError::GetPageState(
-                error.reason(), error.domain(), error.url(), isPost,
-                false, error.stale_copy_in_cache(), false, RenderThreadObserverQt::is_incognito_process(), false,
-                false, false, locale, std::unique_ptr<error_page::ErrorPageParams>());
+                error_page::LocalizedError::GetPageState(
+                        error.reason(), error.domain(), error.url(), isPost, false,
+                        error.stale_copy_in_cache(), false,
+                        RenderConfiguration::is_incognito_process(), false, false, false, locale,
+                        std::unique_ptr<error_page::ErrorPageParams>());
 
         resourceId = IDR_NET_ERROR_HTML;
 
diff --git a/src/core/renderer/content_renderer_client_qt.h b/src/core/renderer/content_renderer_client_qt.h
index 24a841cb8..91bce972f 100644
--- a/src/core/renderer/content_renderer_client_qt.h
+++ b/src/core/renderer/content_renderer_client_qt.h
@@ -75,8 +75,8 @@ struct WebPluginInfo;
 
 namespace QtWebEngineCore {
 
-class RenderThreadObserverQt;
-
+class UserResourceController;
+class RenderConfiguration;
 class ContentRendererClientQt
     : public content::ContentRendererClient
     , public service_manager::LocalInterfaceProvider
@@ -88,7 +88,6 @@ public:
     // content::ContentRendererClient:
     void RenderThreadStarted() override;
     void ExposeInterfacesToBrowser(mojo::BinderMap* binders) override;
-    void RenderViewCreated(content::RenderView *render_view) override;
     void RenderFrameCreated(content::RenderFrame *render_frame) override;
     bool ShouldSuppressErrorPage(content::RenderFrame *, const GURL &) override;
     bool HasErrorPage(int http_status_code) override;
@@ -147,7 +146,8 @@ private:
     void GetNavigationErrorStringsInternal(content::RenderFrame *renderFrame, const std::string &httpMethod,
                                            const error_page::Error &error, std::string *errorHtml);
 
-    QScopedPointer<RenderThreadObserverQt> m_renderThreadObserver;
+    QScopedPointer<RenderConfiguration> m_renderConfiguration;
+    QScopedPointer<UserResourceController> m_userResourceController;
     QScopedPointer<visitedlink::VisitedLinkReader> m_visitedLinkReader;
     QScopedPointer<web_cache::WebCacheImpl> m_webCacheImpl;
 #if QT_CONFIG(webengine_spellchecker)
diff --git a/src/core/renderer/extensions/extensions_renderer_client_qt.cpp b/src/core/renderer/extensions/extensions_renderer_client_qt.cpp
index 7d4c9a83c..fd928df12 100644
--- a/src/core/renderer/extensions/extensions_renderer_client_qt.cpp
+++ b/src/core/renderer/extensions/extensions_renderer_client_qt.cpp
@@ -45,7 +45,7 @@
 #include "extensions_renderer_client_qt.h"
 
 #include "extensions_dispatcher_delegate_qt.h"
-#include "renderer/render_thread_observer_qt.h"
+#include "renderer/render_configuration.h"
 #include "renderer_permissions_policy_delegate_qt.h"
 #include "resource_request_policy_qt.h"
 
@@ -88,7 +88,7 @@ ExtensionsRendererClientQt::~ExtensionsRendererClientQt()
 // Returns true if the current render process was launched incognito.
 bool ExtensionsRendererClientQt::IsIncognitoProcess() const
 {
-    return RenderThreadObserverQt::is_incognito_process();
+    return RenderConfiguration::is_incognito_process();
 }
 
 // Returns the lowest isolated world ID available to extensions.
diff --git a/src/core/renderer/render_thread_observer_qt.cpp b/src/core/renderer/render_configuration.cpp
index 4912ebfc2..ef9da7af7 100644
--- a/src/core/renderer/render_thread_observer_qt.cpp
+++ b/src/core/renderer/render_configuration.cpp
@@ -42,31 +42,34 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "renderer/render_thread_observer_qt.h"
-
+#include "renderer/render_configuration.h"
+#include "user_resource_controller.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 
 namespace QtWebEngineCore {
 
-bool RenderThreadObserverQt::m_isIncognitoProcess = false;
+bool RenderConfiguration::m_isIncognitoProcess = false;
 
-void RenderThreadObserverQt::RegisterMojoInterfaces(blink::AssociatedInterfaceRegistry *associated_interfaces)
+void RenderConfiguration::RegisterMojoInterfaces(
+        blink::AssociatedInterfaceRegistry *associated_interfaces)
 {
     associated_interfaces->AddInterface(
-            base::Bind(&RenderThreadObserverQt::OnRendererConfigurationAssociatedRequest, base::Unretained(this)));
+            base::Bind(&RenderConfiguration::OnRendererConfigurationAssociatedRequest,
+                       base::Unretained(this)));
 }
 
-void RenderThreadObserverQt::UnregisterMojoInterfaces(blink::AssociatedInterfaceRegistry *associated_interfaces)
+void RenderConfiguration::UnregisterMojoInterfaces(
+        blink::AssociatedInterfaceRegistry *associated_interfaces)
 {
     associated_interfaces->RemoveInterface(qtwebengine::mojom::RendererConfiguration::Name_);
 }
 
-void RenderThreadObserverQt::SetInitialConfiguration(bool is_incognito_process)
+void RenderConfiguration::SetInitialConfiguration(bool is_incognito_process)
 {
     m_isIncognitoProcess = is_incognito_process;
 }
 
-void RenderThreadObserverQt::OnRendererConfigurationAssociatedRequest(
+void RenderConfiguration::OnRendererConfigurationAssociatedRequest(
         mojo::PendingAssociatedReceiver<qtwebengine::mojom::RendererConfiguration> receiver)
 {
     m_rendererConfigurationReceivers.Add(this, std::move(receiver));
diff --git a/src/core/renderer/render_thread_observer_qt.h b/src/core/renderer/render_configuration.h
index 05372049b..138a85bdc 100644
--- a/src/core/renderer/render_thread_observer_qt.h
+++ b/src/core/renderer/render_configuration.h
@@ -37,8 +37,8 @@
 **
 ****************************************************************************/
 
-#ifndef RENDER_THREAD_OBSERVER_QT_H
-#define RENDER_THREAD_OBSERVER_QT_H
+#ifndef RENDER_CONFIGURATION_H
+#define RENDER_CONFIGURATION_H
 
 #include "content/public/renderer/render_thread_observer.h"
 #include "mojo/public/cpp/bindings/associated_receiver_set.h"
@@ -47,13 +47,12 @@
 
 namespace QtWebEngineCore {
 
-class RenderThreadObserverQt
-    : public content::RenderThreadObserver
-    , public qtwebengine::mojom::RendererConfiguration
+class RenderConfiguration : public content::RenderThreadObserver,
+                            public qtwebengine::mojom::RendererConfiguration
 {
 public:
-    RenderThreadObserverQt() = default;
-    ~RenderThreadObserverQt() override = default;
+    RenderConfiguration() = default;
+    ~RenderConfiguration() override = default;
 
     static bool is_incognito_process() { return m_isIncognitoProcess; }
 
@@ -70,11 +69,12 @@ private:
 
     static bool m_isIncognitoProcess;
 
-    mojo::AssociatedReceiverSet<qtwebengine::mojom::RendererConfiguration> m_rendererConfigurationReceivers;
+    mojo::AssociatedReceiverSet<qtwebengine::mojom::RendererConfiguration>
+            m_rendererConfigurationReceivers;
 
-    DISALLOW_COPY_AND_ASSIGN(RenderThreadObserverQt);
+    DISALLOW_COPY_AND_ASSIGN(RenderConfiguration);
 };
 
 } // namespace QtWebEngineCore
 
-#endif // RENDER_THREAD_OBSERVER_QT_H
+#endif // RENDER_CONFIGURATION_H
diff --git a/src/core/renderer/user_resource_controller.cpp b/src/core/renderer/user_resource_controller.cpp
index 3c1ad0477..e17498302 100644
--- a/src/core/renderer/user_resource_controller.cpp
+++ b/src/core/renderer/user_resource_controller.cpp
@@ -52,9 +52,12 @@
 #include "third_party/blink/public/web/web_script_source.h"
 #include "third_party/blink/public/web/web_view.h"
 #include "v8/include/v8.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 
 #include "common/qt_messages.h"
-#include "common/user_script_data.h"
+#include "qtwebengine/userscript/user_script_data.h"
 #include "type_conversion.h"
 #include "user_script.h"
 
@@ -62,9 +65,9 @@
 
 #include <bitset>
 
-Q_GLOBAL_STATIC(UserResourceController, qt_webengine_userResourceController)
+namespace QtWebEngineCore {
 
-static content::RenderView *const globalScriptsIndex = nullptr;
+static content::RenderFrame *const globalScriptsIndex = nullptr;
 
 // Scripts meant to run after the load event will be run 500ms after DOMContentLoaded if the load event doesn't come within that delay.
 static const int afterLoadTimeout = 500;
@@ -97,7 +100,7 @@ static bool includeRuleMatchesURL(const std::string &pat, const GURL &url)
     return false;
 }
 
-static bool scriptMatchesURL(const UserScriptData &scriptData, const GURL &url)
+static bool scriptMatchesURL(const QtWebEngineCore::UserScriptData &scriptData, const GURL &url)
 {
     // Logic taken from Chromium (extensions/common/user_script.cc)
     bool matchFound;
@@ -132,10 +135,18 @@ static bool scriptMatchesURL(const UserScriptData &scriptData, const GURL &url)
     return true;
 }
 
-class UserResourceController::RenderFrameObserverHelper : public content::RenderFrameObserver
+// using UserScriptDataPtr = mojo::StructPtr<qtwebengine::mojom::UserScriptData>;
+
+class UserResourceController::RenderFrameObserverHelper
+    : public content::RenderFrameObserver,
+      public qtwebengine::mojom::UserResourceControllerRenderFrame
 {
 public:
-    RenderFrameObserverHelper(content::RenderFrame *render_frame);
+    RenderFrameObserverHelper(content::RenderFrame *render_frame,
+                              UserResourceController *controller);
+    void BindReceiver(
+            mojo::PendingAssociatedReceiver<qtwebengine::mojom::UserResourceControllerRenderFrame>
+                    receiver);
 
 private:
     // RenderFrameObserver implementation.
@@ -144,14 +155,14 @@ private:
     void DidFinishLoad() override;
     void FrameDetached() override;
     void OnDestruct() override;
-    bool OnMessageReceived(const IPC::Message &message) override;
-
-    void onUserScriptAdded(const UserScriptData &);
-    void onUserScriptRemoved(const UserScriptData &);
-    void onScriptsCleared();
+    void AddScript(const QtWebEngineCore::UserScriptData &data) override;
+    void RemoveScript(const QtWebEngineCore::UserScriptData &data) override;
+    void ClearScripts() override;
 
     class Runner;
     QScopedPointer<Runner> m_runner;
+    mojo::AssociatedReceiver<qtwebengine::mojom::UserResourceControllerRenderFrame> m_binding;
+    UserResourceController *m_userResourceController;
 };
 
 // Helper class to create WeakPtrs so the AfterLoad tasks can be canceled and to
@@ -159,13 +170,16 @@ private:
 class UserResourceController::RenderFrameObserverHelper::Runner : public base::SupportsWeakPtr<Runner>
 {
 public:
-    explicit Runner(blink::WebLocalFrame *frame) : m_frame(frame) {}
+    explicit Runner(blink::WebLocalFrame *frame, UserResourceController *controller)
+        : m_frame(frame), m_userResourceController(controller)
+    {
+    }
 
-    void run(UserScriptData::InjectionPoint p)
+    void run(QtWebEngineCore::UserScriptData::InjectionPoint p)
     {
         DCHECK_LT(p, m_ran.size());
         if (!m_ran[p]) {
-            UserResourceController::instance()->runScripts(p, m_frame);
+            m_userResourceController->runScripts(p, m_frame);
             m_ran[p] = true;
         }
     }
@@ -173,35 +187,22 @@ public:
 private:
     blink::WebLocalFrame *m_frame;
     std::bitset<3> m_ran;
+    UserResourceController *m_userResourceController;
 };
 
-// Used only for script cleanup on RenderView destruction.
-class UserResourceController::RenderViewObserverHelper : public content::RenderViewObserver
-{
-public:
-    RenderViewObserverHelper(content::RenderView *render_view);
-
-private:
-    // RenderViewObserver implementation.
-    void OnDestruct() override;
-};
-
-void UserResourceController::runScripts(UserScriptData::InjectionPoint p, blink::WebLocalFrame *frame)
+void UserResourceController::runScripts(QtWebEngineCore::UserScriptData::InjectionPoint p,
+                                        blink::WebLocalFrame *frame)
 {
     content::RenderFrame *renderFrame = content::RenderFrame::FromWebFrame(frame);
     if (!renderFrame)
         return;
     const bool isMainFrame = renderFrame->IsMainFrame();
 
-    content::RenderView *renderView = renderFrame->GetRenderView();
-    if (!renderView)
-        return;
-
-    QList<uint64_t> scriptsToRun = m_viewUserScriptMap.value(0).values();
-    scriptsToRun.append(m_viewUserScriptMap.value(renderView).values());
+    QList<uint64_t> scriptsToRun = m_frameUserScriptMap.value(0).values();
+    scriptsToRun.append(m_frameUserScriptMap.value(renderFrame).values());
 
     for (uint64_t id : qAsConst(scriptsToRun)) {
-        const UserScriptData &script = m_scripts.value(id);
+        const QtWebEngineCore::UserScriptData &script = m_scripts.value(id);
         if (script.injectionPoint != p || (!script.injectForSubframes && !isMainFrame))
             continue;
         if (!scriptMatchesURL(script, frame->GetDocument().Url()))
@@ -216,16 +217,27 @@ void UserResourceController::runScripts(UserScriptData::InjectionPoint p, blink:
 
 void UserResourceController::RunScriptsAtDocumentEnd(content::RenderFrame *render_frame)
 {
-    runScripts(UserScriptData::DocumentLoadFinished, render_frame->GetWebFrame());
+    runScripts(QtWebEngineCore::UserScriptData::DocumentLoadFinished, render_frame->GetWebFrame());
 }
 
-UserResourceController::RenderFrameObserverHelper::RenderFrameObserverHelper(content::RenderFrame *render_frame)
+UserResourceController::RenderFrameObserverHelper::RenderFrameObserverHelper(
+        content::RenderFrame *render_frame, UserResourceController *controller)
     : content::RenderFrameObserver(render_frame)
-{}
+    , m_binding(this)
+    , m_userResourceController(controller)
+{
+    render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
+            base::BindRepeating(&UserResourceController::RenderFrameObserverHelper::BindReceiver,
+                                base::Unretained(this)));
+}
 
-UserResourceController::RenderViewObserverHelper::RenderViewObserverHelper(content::RenderView *render_view)
-    : content::RenderViewObserver(render_view)
-{}
+
+void UserResourceController::RenderFrameObserverHelper::BindReceiver(
+        mojo::PendingAssociatedReceiver<qtwebengine::mojom::UserResourceControllerRenderFrame>
+                receiver)
+{
+    m_binding.Bind(std::move(receiver));
+}
 
 void UserResourceController::RenderFrameObserverHelper::DidCommitProvisionalLoad(bool is_same_document_navigation,
                                                                                  ui::PageTransition /*transitionbool*/)
@@ -237,10 +249,12 @@ void UserResourceController::RenderFrameObserverHelper::DidCommitProvisionalLoad
     // process has been notified of the DidCommitProvisionalLoad event to ensure
     // that the WebChannelTransportHost is ready to receive messages.
 
-    m_runner.reset(new Runner(render_frame()->GetWebFrame()));
+    m_runner.reset(new Runner(render_frame()->GetWebFrame(), m_userResourceController));
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE, base::BindOnce(&Runner::run, m_runner->AsWeakPtr(), UserScriptData::DocumentElementCreation));
+            FROM_HERE,
+            base::BindOnce(&Runner::run, m_runner->AsWeakPtr(),
+                           QtWebEngineCore::UserScriptData::DocumentElementCreation));
 }
 
 void UserResourceController::RenderFrameObserverHelper::DidFinishDocumentLoad()
@@ -249,7 +263,9 @@ void UserResourceController::RenderFrameObserverHelper::DidFinishDocumentLoad()
     // called instead of DidCommitProvisionalLoad).
     if (m_runner)
         base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-                FROM_HERE, base::BindOnce(&Runner::run, m_runner->AsWeakPtr(), UserScriptData::AfterLoad),
+                FROM_HERE,
+                base::BindOnce(&Runner::run, m_runner->AsWeakPtr(),
+                               QtWebEngineCore::UserScriptData::AfterLoad),
                 base::TimeDelta::FromMilliseconds(afterLoadTimeout));
 }
 
@@ -257,7 +273,9 @@ void UserResourceController::RenderFrameObserverHelper::DidFinishLoad()
 {
     if (m_runner)
         base::ThreadTaskRunnerHandle::Get()->PostTask(
-                FROM_HERE, base::BindOnce(&Runner::run, m_runner->AsWeakPtr(), UserScriptData::AfterLoad));
+                FROM_HERE,
+                base::BindOnce(&Runner::run, m_runner->AsWeakPtr(),
+                               QtWebEngineCore::UserScriptData::AfterLoad));
 }
 
 void UserResourceController::RenderFrameObserverHelper::FrameDetached()
@@ -267,68 +285,39 @@ void UserResourceController::RenderFrameObserverHelper::FrameDetached()
 
 void UserResourceController::RenderFrameObserverHelper::OnDestruct()
 {
+    if (content::RenderFrame *frame = render_frame()) {
+        m_userResourceController->renderFrameDestroyed(frame);
+    }
     delete this;
 }
 
-void UserResourceController::RenderViewObserverHelper::OnDestruct()
-{
-    // Remove all scripts associated with the render view.
-    if (content::RenderView *view = render_view())
-        UserResourceController::instance()->renderViewDestroyed(view);
-    delete this;
-}
-
-bool UserResourceController::RenderFrameObserverHelper::OnMessageReceived(const IPC::Message &message)
-{
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(UserResourceController::RenderFrameObserverHelper, message)
-        IPC_MESSAGE_HANDLER(RenderFrameObserverHelper_AddScript, onUserScriptAdded)
-        IPC_MESSAGE_HANDLER(RenderFrameObserverHelper_RemoveScript, onUserScriptRemoved)
-        IPC_MESSAGE_HANDLER(RenderFrameObserverHelper_ClearScripts, onScriptsCleared)
-        IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-}
-
-void UserResourceController::RenderFrameObserverHelper::onUserScriptAdded(const UserScriptData &script)
+void UserResourceController::RenderFrameObserverHelper::AddScript(
+        const QtWebEngineCore::UserScriptData &script)
 {
     if (content::RenderFrame *frame = render_frame())
-        if (content::RenderView *view = frame->GetRenderView())
-            UserResourceController::instance()->addScriptForView(script, view);
+        m_userResourceController->addScriptForFrame(script, frame);
 }
 
-void UserResourceController::RenderFrameObserverHelper::onUserScriptRemoved(const UserScriptData &script)
+void UserResourceController::RenderFrameObserverHelper::RemoveScript(
+        const QtWebEngineCore::UserScriptData &script)
 {
     if (content::RenderFrame *frame = render_frame())
-        if (content::RenderView *view = frame->GetRenderView())
-            UserResourceController::instance()->removeScriptForView(script, view);
+        m_userResourceController->removeScriptForFrame(script, frame);
 }
 
-void UserResourceController::RenderFrameObserverHelper::onScriptsCleared()
+void UserResourceController::RenderFrameObserverHelper::ClearScripts()
 {
     if (content::RenderFrame *frame = render_frame())
-        if (content::RenderView *view = frame->GetRenderView())
-            UserResourceController::instance()->clearScriptsForView(view);
+        m_userResourceController->clearScriptsForFrame(frame);
 }
 
-UserResourceController *UserResourceController::instance()
+void UserResourceController::BindReceiver(
+        mojo::PendingAssociatedReceiver<qtwebengine::mojom::UserResourceController> receiver)
 {
-    return qt_webengine_userResourceController();
+    m_binding.Bind(std::move(receiver));
 }
 
-bool UserResourceController::OnControlMessageReceived(const IPC::Message &message)
-{
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(UserResourceController, message)
-        IPC_MESSAGE_HANDLER(UserResourceController_AddScript, onAddScript)
-        IPC_MESSAGE_HANDLER(UserResourceController_RemoveScript, onRemoveScript)
-        IPC_MESSAGE_HANDLER(UserResourceController_ClearScripts, onClearScripts)
-        IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
-}
-
-UserResourceController::UserResourceController()
+UserResourceController::UserResourceController() : m_binding(this)
 {
 #if !defined(QT_NO_DEBUG) || defined(QT_FORCE_ASSERTS)
     static bool onlyCalledOnce = true;
@@ -340,68 +329,79 @@ UserResourceController::UserResourceController()
 void UserResourceController::renderFrameCreated(content::RenderFrame *renderFrame)
 {
     // Will destroy itself when the RenderFrame is destroyed.
-    new RenderFrameObserverHelper(renderFrame);
+    new RenderFrameObserverHelper(renderFrame, this);
 }
 
-void UserResourceController::renderViewCreated(content::RenderView *renderView)
+void UserResourceController::renderFrameDestroyed(content::RenderFrame *renderFrame)
 {
-    // Will destroy itself when the RenderView is destroyed.
-    new RenderViewObserverHelper(renderView);
-}
-
-void UserResourceController::renderViewDestroyed(content::RenderView *renderView)
-{
-    ViewUserScriptMap::iterator it = m_viewUserScriptMap.find(renderView);
-    if (it == m_viewUserScriptMap.end()) // ASSERT maybe?
+    FrameUserScriptMap::iterator it = m_frameUserScriptMap.find(renderFrame);
+    if (it == m_frameUserScriptMap.end()) // ASSERT maybe?
         return;
     for (uint64_t id : qAsConst(it.value())) {
         m_scripts.remove(id);
     }
-    m_viewUserScriptMap.remove(renderView);
+    m_frameUserScriptMap.remove(renderFrame);
 }
 
-void UserResourceController::addScriptForView(const UserScriptData &script, content::RenderView *view)
+void UserResourceController::addScriptForFrame(const QtWebEngineCore::UserScriptData &script,
+                                               content::RenderFrame *frame)
 {
-    ViewUserScriptMap::iterator it = m_viewUserScriptMap.find(view);
-    if (it == m_viewUserScriptMap.end())
-        it = m_viewUserScriptMap.insert(view, UserScriptSet());
+    FrameUserScriptMap::iterator it = m_frameUserScriptMap.find(frame);
+    if (it == m_frameUserScriptMap.end())
+        it = m_frameUserScriptMap.insert(frame, UserScriptSet());
 
     (*it).insert(script.scriptId);
     m_scripts.insert(script.scriptId, script);
 }
 
-void UserResourceController::removeScriptForView(const UserScriptData &script, content::RenderView *view)
+void UserResourceController::removeScriptForFrame(const QtWebEngineCore::UserScriptData &script,
+                                                  content::RenderFrame *frame)
 {
-    ViewUserScriptMap::iterator it = m_viewUserScriptMap.find(view);
-    if (it == m_viewUserScriptMap.end())
+    FrameUserScriptMap::iterator it = m_frameUserScriptMap.find(frame);
+    if (it == m_frameUserScriptMap.end())
         return;
 
     (*it).remove(script.scriptId);
     m_scripts.remove(script.scriptId);
 }
 
-void UserResourceController::clearScriptsForView(content::RenderView *view)
+void UserResourceController::clearScriptsForFrame(content::RenderFrame *frame)
 {
-    ViewUserScriptMap::iterator it = m_viewUserScriptMap.find(view);
-    if (it == m_viewUserScriptMap.end())
+    FrameUserScriptMap::iterator it = m_frameUserScriptMap.find(frame);
+    if (it == m_frameUserScriptMap.end())
         return;
     for (uint64_t id : qAsConst(it.value()))
         m_scripts.remove(id);
 
-    m_viewUserScriptMap.remove(view);
+    m_frameUserScriptMap.remove(frame);
+}
+
+void UserResourceController::AddScript(const QtWebEngineCore::UserScriptData &script)
+{
+    addScriptForFrame(script, globalScriptsIndex);
 }
 
-void UserResourceController::onAddScript(const UserScriptData &script)
+void UserResourceController::RemoveScript(const QtWebEngineCore::UserScriptData &script)
 {
-    addScriptForView(script, globalScriptsIndex);
+    removeScriptForFrame(script, globalScriptsIndex);
 }
 
-void UserResourceController::onRemoveScript(const UserScriptData &script)
+void UserResourceController::ClearScripts()
 {
-    removeScriptForView(script, globalScriptsIndex);
+    clearScriptsForFrame(globalScriptsIndex);
 }
 
-void UserResourceController::onClearScripts()
+void UserResourceController::RegisterMojoInterfaces(
+        blink::AssociatedInterfaceRegistry *associated_interfaces)
 {
-    clearScriptsForView(globalScriptsIndex);
+    associated_interfaces->AddInterface(
+            base::Bind(&UserResourceController::BindReceiver, base::Unretained(this)));
 }
+
+void UserResourceController::UnregisterMojoInterfaces(
+        blink::AssociatedInterfaceRegistry *associated_interfaces)
+{
+    associated_interfaces->RemoveInterface(qtwebengine::mojom::UserResourceController::Name_);
+}
+
+} // namespace
diff --git a/src/core/renderer/user_resource_controller.h b/src/core/renderer/user_resource_controller.h
index 3a493b9b7..6c79d96fc 100644
--- a/src/core/renderer/user_resource_controller.h
+++ b/src/core/renderer/user_resource_controller.h
@@ -41,8 +41,9 @@
 #define USER_RESOURCE_CONTROLLER_H
 
 #include "content/public/renderer/render_thread_observer.h"
-
-#include "common/user_script_data.h"
+#include "qtwebengine/userscript/userscript.mojom.h"
+#include "qtwebengine/userscript/user_script_data.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
 
 #include <QtCore/QHash>
 #include <QtCore/QSet>
@@ -56,42 +57,46 @@ class RenderFrame;
 class RenderView;
 }
 
-class UserResourceController : public content::RenderThreadObserver
+namespace QtWebEngineCore {
+
+class UserResourceController : public content::RenderThreadObserver,
+                               qtwebengine::mojom::UserResourceController
 {
 
 public:
-    static UserResourceController *instance();
     UserResourceController();
     void renderFrameCreated(content::RenderFrame *);
-    void renderViewCreated(content::RenderView *);
-    void renderViewDestroyed(content::RenderView *renderView);
-    void addScriptForView(const UserScriptData &, content::RenderView *);
-    void removeScriptForView(const UserScriptData &, content::RenderView *);
-    void clearScriptsForView(content::RenderView *);
+    void renderFrameDestroyed(content::RenderFrame *);
+    void addScriptForFrame(const QtWebEngineCore::UserScriptData &, content::RenderFrame *);
+    void removeScriptForFrame(const QtWebEngineCore::UserScriptData &, content::RenderFrame *);
+    void clearScriptsForFrame(content::RenderFrame *);
 
     void RunScriptsAtDocumentEnd(content::RenderFrame *render_frame);
+    void BindReceiver(
+            mojo::PendingAssociatedReceiver<qtwebengine::mojom::UserResourceController> receiver);
 
 private:
     Q_DISABLE_COPY(UserResourceController)
 
+    // content::RenderThreadObserver:
+    void RegisterMojoInterfaces(blink::AssociatedInterfaceRegistry *associated_interfaces) override;
+    void UnregisterMojoInterfaces(blink::AssociatedInterfaceRegistry *associated_interfaces) override;
+
     class RenderFrameObserverHelper;
     class RenderViewObserverHelper;
 
-    // RenderProcessObserver implementation.
-    bool OnControlMessageReceived(const IPC::Message &message) override;
+    void AddScript(const QtWebEngineCore::UserScriptData &data) override;
+    void RemoveScript(const QtWebEngineCore::UserScriptData &data) override;
+    void ClearScripts() override;
 
-    void onAddScript(const UserScriptData &);
-    void onRemoveScript(const UserScriptData &);
-    void onClearScripts();
-
-    void runScripts(UserScriptData::InjectionPoint, blink::WebLocalFrame *);
+    void runScripts(QtWebEngineCore::UserScriptData::InjectionPoint, blink::WebLocalFrame *);
 
     typedef QSet<uint64_t> UserScriptSet;
-    typedef QHash<const content::RenderView *, UserScriptSet> ViewUserScriptMap;
-    ViewUserScriptMap m_viewUserScriptMap;
-    QHash<uint64_t, UserScriptData> m_scripts;
-
+    typedef QHash<const content::RenderFrame *, UserScriptSet> FrameUserScriptMap;
+    FrameUserScriptMap m_frameUserScriptMap;
+    QHash<uint64_t, QtWebEngineCore::UserScriptData> m_scripts;
+    mojo::AssociatedReceiver<qtwebengine::mojom::UserResourceController> m_binding;
     friend class RenderFrameObserverHelper;
 };
-
+} // namespace
 #endif // USER_RESOURCE_CONTROLLER_H
diff --git a/src/core/renderer/web_channel_ipc_transport.cpp b/src/core/renderer/web_channel_ipc_transport.cpp
index 496417329..1efefc1d0 100644
--- a/src/core/renderer/web_channel_ipc_transport.cpp
+++ b/src/core/renderer/web_channel_ipc_transport.cpp
@@ -74,7 +74,8 @@ private:
 
     // gin::WrappableBase
     gin::ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate *isolate) override;
-
+    mojo::AssociatedRemote<qtwebchannel::mojom::WebChannelTransportHost> m_remote;
+    content::RenderFrame *m_renderFrame = nullptr;
     DISALLOW_COPY_AND_ASSIGN(WebChannelTransport);
 };
 
@@ -156,9 +157,13 @@ void WebChannelTransport::NativeQtSendMessage(gin::Arguments *args)
     jsonString->WriteUtf8(isolate, reinterpret_cast<char *>(json.data()), json.size(), nullptr,
                           v8::String::REPLACE_INVALID_UTF8);
 
-    mojo::AssociatedRemote<qtwebchannel::mojom::WebChannelTransportHost> webChannelTransport;
-    renderFrame->GetRemoteAssociatedInterfaces()->GetInterface(&webChannelTransport);
-    webChannelTransport->DispatchWebChannelMessage(json);
+    if (!m_remote) {
+        renderFrame->GetRemoteAssociatedInterfaces()->GetInterface(&m_remote);
+        m_renderFrame = renderFrame;
+    }
+    DCHECK(renderFrame == m_renderFrame);
+
+    m_remote->DispatchWebChannelMessage(json);
 }
 
 gin::ObjectTemplateBuilder WebChannelTransport::GetObjectTemplateBuilder(v8::Isolate *isolate)
@@ -168,7 +173,10 @@ gin::ObjectTemplateBuilder WebChannelTransport::GetObjectTemplateBuilder(v8::Iso
 }
 
 WebChannelIPCTransport::WebChannelIPCTransport(content::RenderFrame *renderFrame)
-    : content::RenderFrameObserver(renderFrame), m_worldId(0), m_worldInitialized(false)
+    : content::RenderFrameObserver(renderFrame)
+    , m_worldId(0)
+    , m_worldInitialized(false)
+    , m_binding(this)
 {
     renderFrame->GetAssociatedInterfaceRegistry()->AddInterface(
             base::BindRepeating(&WebChannelIPCTransport::BindReceiver, base::Unretained(this)));
@@ -177,7 +185,7 @@ WebChannelIPCTransport::WebChannelIPCTransport(content::RenderFrame *renderFrame
 void WebChannelIPCTransport::BindReceiver(
         mojo::PendingAssociatedReceiver<qtwebchannel::mojom::WebChannelTransportRender> receiver)
 {
-    m_receivers.Add(this, std::move(receiver));
+    m_binding.Bind(std::move(receiver));
 }
 
 void WebChannelIPCTransport::SetWorldId(uint32_t worldId)
diff --git a/src/core/renderer/web_channel_ipc_transport.h b/src/core/renderer/web_channel_ipc_transport.h
index 7c3b21eec..276167a67 100644
--- a/src/core/renderer/web_channel_ipc_transport.h
+++ b/src/core/renderer/web_channel_ipc_transport.h
@@ -76,7 +76,7 @@ private:
     bool m_worldInitialized;
     // True means it's currently OK to manipulate the frame's script context.
     bool m_canUseContext = false;
-    mojo::AssociatedReceiverSet<qtwebchannel::mojom::WebChannelTransportRender> m_receivers;
+    mojo::AssociatedReceiver<qtwebchannel::mojom::WebChannelTransportRender> m_binding;
 };
 
 } // namespace
diff --git a/src/core/renderer/render_view_observer_qt.cpp b/src/core/renderer/web_engine_page_render_frame.cpp
index 5b0b9a77d..add1788d6 100644
--- a/src/core/renderer/render_view_observer_qt.cpp
+++ b/src/core/renderer/web_engine_page_render_frame.cpp
@@ -37,11 +37,11 @@
 **
 ****************************************************************************/
 
-#include "renderer/render_view_observer_qt.h"
+#include "renderer/web_engine_page_render_frame.h"
+#include "content/public/renderer/render_frame.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 
-#include "common/qt_messages.h"
-
-#include "content/public/renderer/render_view.h"
 #include "third_party/blink/public/web/web_document.h"
 #include "third_party/blink/public/web/web_element.h"
 #include "third_party/blink/public/web/web_frame.h"
@@ -50,45 +50,45 @@
 #include "third_party/blink/public/web/web_local_frame.h"
 #include "third_party/blink/public/web/web_view.h"
 
-RenderViewObserverQt::RenderViewObserverQt(content::RenderView *render_view) : content::RenderViewObserver(render_view)
-{}
+namespace QtWebEngineCore {
 
-void RenderViewObserverQt::onFetchDocumentMarkup(quint64 requestId)
+WebEnginePageRenderFrame::WebEnginePageRenderFrame(content::RenderFrame *render_frame)
+    : content::RenderFrameObserver(render_frame), m_binding(this)
 {
-    blink::WebString markup;
-    if (render_view()->GetWebView()->MainFrame()->IsWebLocalFrame())
-        markup = blink::WebFrameContentDumper::DumpAsMarkup(
-                static_cast<blink::WebLocalFrame *>(render_view()->GetWebView()->MainFrame()));
-    Send(new RenderViewObserverHostQt_DidFetchDocumentMarkup(routing_id(), requestId, markup.Utf16()));
+    render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
+            base::BindRepeating(&WebEnginePageRenderFrame::BindReceiver, base::Unretained(this)));
 }
 
-void RenderViewObserverQt::onFetchDocumentInnerText(quint64 requestId)
+void WebEnginePageRenderFrame::BindReceiver(
+        mojo::PendingAssociatedReceiver<qtwebenginepage::mojom::WebEnginePageRenderFrame> receiver)
 {
-    blink::WebString text;
-    if (render_view()->GetWebView()->MainFrame()->IsWebLocalFrame())
-        text = blink::WebFrameContentDumper::DumpWebViewAsText(render_view()->GetWebView(),
-                                                               std::numeric_limits<std::size_t>::max());
-    Send(new RenderViewObserverHostQt_DidFetchDocumentInnerText(routing_id(), requestId, text.Utf16()));
+    m_binding.Bind(std::move(receiver));
 }
 
-void RenderViewObserverQt::onSetBackgroundColor(quint32 color)
+void WebEnginePageRenderFrame::FetchDocumentMarkup(uint64_t requestId,
+                                                   FetchDocumentMarkupCallback callback)
 {
-    render_view()->GetWebView()->SetBaseBackgroundColorOverride(color);
+    blink::WebString markup =
+            blink::WebFrameContentDumper::DumpAsMarkup(render_frame()->GetWebFrame());
+    std::move(callback).Run(requestId, markup.Utf8());
 }
 
-void RenderViewObserverQt::OnDestruct()
+void WebEnginePageRenderFrame::FetchDocumentInnerText(uint64_t requestId,
+                                                      FetchDocumentInnerTextCallback callback)
 {
-    delete this;
+    blink::WebString text = blink::WebFrameContentDumper::DumpWebViewAsText(
+            render_frame()->GetWebFrame()->View(), std::numeric_limits<std::size_t>::max());
+    std::move(callback).Run(requestId, text.Utf8());
+}
+
+void WebEnginePageRenderFrame::SetBackgroundColor(uint32_t color)
+{
+    render_frame()->GetWebFrame()->View()->SetBaseBackgroundColorOverride(color);
 }
 
-bool RenderViewObserverQt::OnMessageReceived(const IPC::Message &message)
+void WebEnginePageRenderFrame::OnDestruct()
 {
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(RenderViewObserverQt, message)
-        IPC_MESSAGE_HANDLER(RenderViewObserverQt_FetchDocumentMarkup, onFetchDocumentMarkup)
-        IPC_MESSAGE_HANDLER(RenderViewObserverQt_FetchDocumentInnerText, onFetchDocumentInnerText)
-        IPC_MESSAGE_HANDLER(RenderViewObserverQt_SetBackgroundColor, onSetBackgroundColor)
-        IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
+    delete this;
+}
+
 }
diff --git a/src/core/renderer/render_view_observer_qt.h b/src/core/renderer/web_engine_page_render_frame.h
index 5c555b222..3fb4657c5 100644
--- a/src/core/renderer/render_view_observer_qt.h
+++ b/src/core/renderer/web_engine_page_render_frame.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2020 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtWebEngine module of the Qt Toolkit.
@@ -36,28 +36,40 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-#ifndef RENDER_VIEW_OBSERVER_QT_H
-#define RENDER_VIEW_OBSERVER_QT_H
+#ifndef WEB_ENGINE_PAGE_RENDER_FRAME_H
+#define WEB_ENGINE_PAGE_RENDER_FRAME_H
 
-#include "content/public/renderer/render_view_observer.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "mojo/public/cpp/bindings/associated_receiver.h"
+#include "qtwebengine/browser/qtwebenginepage.mojom.h"
 
-#include <QtGlobal>
+namespace content {
+class RenderFrame;
+}
 
-class RenderViewObserverQt : public content::RenderViewObserver
+namespace QtWebEngineCore {
+
+class WebEnginePageRenderFrame : private content::RenderFrameObserver,
+                                 public qtwebenginepage::mojom::WebEnginePageRenderFrame
 {
 public:
-    RenderViewObserverQt(content::RenderView *render_view);
+    WebEnginePageRenderFrame(content::RenderFrame *render_frame);
+    WebEnginePageRenderFrame(const WebEnginePageRenderFrame &) = delete;
+    WebEnginePageRenderFrame &operator=(const WebEnginePageRenderFrame &) = delete;
 
 private:
-    void onFetchDocumentMarkup(quint64 requestId);
-    void onFetchDocumentInnerText(quint64 requestId);
-    void onSetBackgroundColor(quint32 color);
-
+    void FetchDocumentMarkup(uint64_t requestId, FetchDocumentMarkupCallback callback) override;
+    void FetchDocumentInnerText(uint64_t requestId,
+                                FetchDocumentInnerTextCallback callback) override;
+    void SetBackgroundColor(uint32_t color) override;
     void OnDestruct() override;
+    void
+    BindReceiver(mojo::PendingAssociatedReceiver<qtwebenginepage::mojom::WebEnginePageRenderFrame>
+                         receiver);
 
-    bool OnMessageReceived(const IPC::Message &message) override;
-
-    DISALLOW_COPY_AND_ASSIGN(RenderViewObserverQt);
+private:
+    mojo::AssociatedReceiver<qtwebenginepage::mojom::WebEnginePageRenderFrame> m_binding;
 };
+} // namespace
 
-#endif // RENDER_VIEW_OBSERVER_QT_H
+#endif // WEB_ENGINE_PAGE_RENDER_FRAME_H