Migrate render_view_observer_qt to mojo

Since mojo interface no longer works on render view, but
on render frame rename the class to be WebEnginePageHost
and WebEnginePageRenderFrame

Keep SetBackgroundColor render message, since it is required
to things work.

Change-Id: I4d6b70dd448926f8ac2d75d2b87f3d490a4cfefb
Reviewed-by: Allan Sandfeld Jensen <[email protected]>

Author: Michal Klocek

src/core/common/qt_messages.h

@@ -12,37 +12,15 @@
 
 #define IPC_MESSAGE_START QtMsgStart
 
-//-----------------------------------------------------------------------------
-// RenderView messages
-// These are messages sent from the browser to the renderer process.
-
-IPC_MESSAGE_ROUTED1(RenderViewObserverQt_FetchDocumentMarkup,
-                    uint64_t /* requestId */)
-
-IPC_MESSAGE_ROUTED1(RenderViewObserverQt_FetchDocumentInnerText,
-                    uint64_t /* requestId */)
-
-IPC_MESSAGE_ROUTED1(RenderViewObserverQt_SetBackgroundColor,
-                    uint32_t /* color */)
-
 // Tells the renderer whether or not a file system access has been allowed.
 IPC_MESSAGE_ROUTED2(QtWebEngineMsg_RequestFileSystemAccessAsyncResponse,
                     int  /* request_id */,
                     bool /* allowed */)
 
-
 //-----------------------------------------------------------------------------
 // WebContents messages
 // These are messages sent from the renderer back to the browser process.
 
-IPC_MESSAGE_ROUTED2(RenderViewObserverHostQt_DidFetchDocumentMarkup,
-                    uint64_t /* requestId */,
-                    base::string16 /* markup */)
-
-IPC_MESSAGE_ROUTED2(RenderViewObserverHostQt_DidFetchDocumentInnerText,
-                    uint64_t /* requestId */,
-                    base::string16 /* innerText */)
-
 IPC_MESSAGE_ROUTED0(RenderViewObserverHostQt_DidFirstVisuallyNonEmptyLayout)
 
 //-----------------------------------------------------------------------------

src/core/core_chromium.pri

@@ -110,11 +110,11 @@ SOURCES = \
         renderer/content_renderer_client_qt.cpp \
         renderer/content_settings_observer_qt.cpp \
         renderer/render_frame_observer_qt.cpp \
-        renderer/render_view_observer_qt.cpp \
+        renderer/web_engine_page_render_frame.cpp \
         renderer/render_configuration.cpp \
         renderer/user_resource_controller.cpp \
         renderer/plugins/plugin_placeholder_qt.cpp \
-        renderer_host/render_view_observer_host_qt.cpp \
+        renderer_host/web_engine_page_host.cpp \
         renderer_host/user_resource_controller_host.cpp \
         resource_bundle_qt.cpp \
         resource_context_qt.cpp \
@@ -215,11 +215,11 @@ HEADERS = \
         renderer/content_renderer_client_qt.h \
         renderer/content_settings_observer_qt.h \
         renderer/render_frame_observer_qt.h \
-        renderer/render_view_observer_qt.h \
+        renderer/web_engine_page_render_frame.h \
         renderer/render_configuration.h \
         renderer/user_resource_controller.h \
         renderer/plugins/plugin_placeholder_qt.h \
-        renderer_host/render_view_observer_host_qt.h \
+        renderer_host/web_engine_page_host.h \
         renderer_host/user_resource_controller_host.h \
         request_controller.h \
         resource_context_qt.h \

src/core/render_widget_host_view_qt.cpp

@@ -527,8 +527,6 @@ void RenderWidgetHostViewQt::UpdateBackgroundColor()
     content::RenderViewHost *rvh = content::RenderViewHost::From(host());
     if (color == SK_ColorTRANSPARENT)
         host()->owner_delegate()->SetBackgroundOpaque(false);
-    else
-        host()->Send(new RenderViewObserverQt_SetBackgroundColor(rvh->GetRoutingID(), color));
 }
 
 // Return value indicates whether the mouse is locked successfully or not.

src/core/renderer/content_renderer_client_qt.cpp

@@ -83,7 +83,7 @@
 
 #include "common/qt_messages.h"
 #include "renderer/render_frame_observer_qt.h"
-#include "renderer/render_view_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)
@@ -188,20 +188,16 @@ void ContentRendererClientQt::ExposeInterfacesToBrowser(mojo::BinderMap* binders
 #endif
 }
 
-void ContentRendererClientQt::RenderViewCreated(content::RenderView *render_view)
-{
-    // RenderViewObservers destroy themselves with their RenderView.
-    new RenderViewObserverQt(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);
+    }
 
     m_userResourceController->renderFrameCreated(render_frame);
 

src/core/renderer/content_renderer_client_qt.h

@@ -88,7 +88,6 @@ class ContentRendererClientQt
     // 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 &, int error_code) override;
     bool HasErrorPage(int http_status_code) override;

src/core/renderer/render_view_observer_qt.cpp renamed to 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;
+}
+
 }

src/core/renderer/render_view_observer_qt.h renamed to 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

src/core/renderer_host/render_view_observer_host_qt.cpp renamed to src/core/renderer_host/web_engine_page_host.cpp

@@ -37,59 +37,76 @@
 **
 ****************************************************************************/
 
-#include "render_view_observer_host_qt.h"
+#include "web_engine_page_host.h"
 
-#include "common/qt_messages.h"
-#include "content/public/browser/render_view_host.h"
+#include "qtwebengine/browser/qtwebenginepage.mojom.h"
 #include "content/public/browser/web_contents.h"
 
 #include "render_widget_host_view_qt.h"
 #include "type_conversion.h"
 #include "web_contents_adapter_client.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 
 namespace QtWebEngineCore {
 
-RenderViewObserverHostQt::RenderViewObserverHostQt(content::WebContents *webContents, WebContentsAdapterClient *adapterClient)
-    : content::WebContentsObserver(webContents)
-    , m_adapterClient(adapterClient)
+WebEnginePageHost::WebEnginePageHost(content::WebContents *webContents,
+                                     WebContentsAdapterClient *adapterClient)
+    : content::WebContentsObserver(webContents), m_adapterClient(adapterClient)
 {
 }
 
-void RenderViewObserverHostQt::fetchDocumentMarkup(quint64 requestId)
+void WebEnginePageHost::FetchDocumentMarkup(uint64_t requestId)
 {
-    web_contents()->GetRenderViewHost()->Send(
-                new RenderViewObserverQt_FetchDocumentMarkup(
-                        web_contents()->GetRenderViewHost()->GetRoutingID(), requestId));
+    auto &remote = GetWebEnginePageRenderFrame(web_contents()->GetMainFrame());
+    remote->FetchDocumentMarkup(
+            requestId,
+            base::BindOnce(&WebEnginePageHost::OnDidFetchDocumentMarkup, base::Unretained(this)));
 }
 
-void RenderViewObserverHostQt::fetchDocumentInnerText(quint64 requestId)
+void WebEnginePageHost::FetchDocumentInnerText(uint64_t requestId)
 {
-    web_contents()->GetRenderViewHost()->Send(
-                new RenderViewObserverQt_FetchDocumentInnerText(
-                        web_contents()->GetRenderViewHost()->GetRoutingID(), requestId));
+    auto &remote = GetWebEnginePageRenderFrame(web_contents()->GetMainFrame());
+    remote->FetchDocumentInnerText(requestId,
+                                   base::BindOnce(&WebEnginePageHost::OnDidFetchDocumentInnerText,
+                                                  base::Unretained(this)));
 }
 
-bool RenderViewObserverHostQt::OnMessageReceived(const IPC::Message &message)
+void WebEnginePageHost::OnDidFetchDocumentMarkup(uint64_t requestId, const std::string &markup)
 {
-    bool handled = true;
-    IPC_BEGIN_MESSAGE_MAP(RenderViewObserverHostQt, message)
-        IPC_MESSAGE_HANDLER(RenderViewObserverHostQt_DidFetchDocumentMarkup,
-                            onDidFetchDocumentMarkup)
-        IPC_MESSAGE_HANDLER(RenderViewObserverHostQt_DidFetchDocumentInnerText,
-                            onDidFetchDocumentInnerText)
-        IPC_MESSAGE_UNHANDLED(handled = false)
-    IPC_END_MESSAGE_MAP()
-    return handled;
+    m_adapterClient->didFetchDocumentMarkup(requestId, toQt(markup));
 }
 
-void RenderViewObserverHostQt::onDidFetchDocumentMarkup(quint64 requestId, const base::string16 &markup)
+void WebEnginePageHost::OnDidFetchDocumentInnerText(uint64_t requestId,
+                                                    const std::string &innerText)
 {
-    m_adapterClient->didFetchDocumentMarkup(requestId, toQt(markup));
+    m_adapterClient->didFetchDocumentInnerText(requestId, toQt(innerText));
 }
 
-void RenderViewObserverHostQt::onDidFetchDocumentInnerText(quint64 requestId, const base::string16 &innerText)
+void WebEnginePageHost::RenderFrameDeleted(content::RenderFrameHost *render_frame)
 {
-    m_adapterClient->didFetchDocumentInnerText(requestId, toQt(innerText));
+    m_renderFrames.erase(render_frame);
+}
+
+void WebEnginePageHost::SetBackgroundColor(uint32_t color)
+{
+    auto &remote = GetWebEnginePageRenderFrame(web_contents()->GetMainFrame());
+    remote->SetBackgroundColor(color);
+}
+
+const WebEnginePageRenderFrameRemote &
+WebEnginePageHost::GetWebEnginePageRenderFrame(content::RenderFrameHost *rfh)
+{
+    auto it = m_renderFrames.find(rfh);
+    if (it == m_renderFrames.end()) {
+        WebEnginePageRenderFrameRemote remote;
+        rfh->GetRemoteAssociatedInterfaces()->GetInterface(remote.BindNewEndpointAndPassReceiver());
+        it = m_renderFrames.insert(std::make_pair(rfh, std::move(remote))).first;
+    } else if (it->second.is_bound() && !it->second.is_connected()) {
+        it->second.reset();
+        rfh->GetRemoteAssociatedInterfaces()->GetInterface(&it->second);
+    }
+
+    return it->second;
 }
 
 } // namespace QtWebEngineCore