[prerender] Convert PrerenderMsg_SetIsPrerendering to mojo

This CL converts PrerenderMsg_SetIsPrerendering to
ChromeRenderFrame Mojo message, and pass the message to
chromePluginPlaceholder from ChromeRenderFrameObserver via
PrerenderObserver.

Bug: 798712
Change-Id: Id84240d8f16fc811df56fc05a734a4ee539c2a91
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2246015Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Darin Fisher <darin@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Cr-Commit-Position: refs/heads/master@{#782849}

chrome/browser/prerender/prerender_contents.cc

@@ -26,6 +26,7 @@
 #include "chrome/browser/task_manager/web_contents_tags.h"
 #include "chrome/browser/ui/tab_helpers.h"
 #include "chrome/browser/ui/web_contents_sizer.h"
+#include "chrome/common/chrome_render_frame.mojom.h"
 #include "chrome/common/prerender_util.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/prerender/common/prerender_final_status.h"
@@ -46,6 +47,7 @@
 #include "net/http/http_response_headers.h"
 #include "services/resource_coordinator/public/cpp/memory_instrumentation/memory_instrumentation.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/gfx/geometry/size.h"
 
@@ -435,9 +437,11 @@ void PrerenderContents::RenderFrameCreated(
   // new RenderFrame it's being used for prerendering before any navigations
   // occur.  Note that this is always triggered before the first navigation, so
   // there's no need to send the message just after the WebContents is created.
-  render_frame_host->Send(new PrerenderMsg_SetIsPrerendering(
-      render_frame_host->GetRoutingID(), prerender_mode_,
-      PrerenderHistograms::GetHistogramPrefix(origin_)));
+  mojo::AssociatedRemote<chrome::mojom::ChromeRenderFrame> chrome_render_frame;
+  render_frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
+      &chrome_render_frame);
+  chrome_render_frame->SetIsPrerendering(
+      prerender_mode_, PrerenderHistograms::GetHistogramPrefix(origin_));
 }
 
 void PrerenderContents::DidStopLoading() {
@@ -632,9 +636,15 @@ void PrerenderContents::PrepareForUse() {
   SetFinalStatus(FINAL_STATUS_USED);
 
   if (prerender_contents_.get()) {
-    prerender_contents_->SendToAllFrames(new PrerenderMsg_SetIsPrerendering(
-        MSG_ROUTING_NONE, prerender::mojom::PrerenderMode::kNoPrerender,
-        std::string()));
+    auto frames = prerender_contents_->GetAllFrames();
+    for (auto* frame : frames) {
+      mojo::AssociatedRemote<chrome::mojom::ChromeRenderFrame>
+          chrome_render_frame;
+      frame->GetRemoteAssociatedInterfaces()->GetInterface(
+          &chrome_render_frame);
+      chrome_render_frame->SetIsPrerendering(
+          prerender::mojom::PrerenderMode::kNoPrerender, std::string());
+    }
   }
 
   NotifyPrerenderStop();

chrome/common/BUILD.gn

@@ -730,6 +730,7 @@ mojom("mojo_bindings") {
 
   public_deps = [
     "//components/content_settings/core/common:mojo_bindings",
+    "//components/prerender/common:mojo_bindings",
     "//content/public/common:client_hints_mojom",
     "//content/public/common:interfaces",
     "//mojo/public/mojom/base",

chrome/common/chrome_render_frame.mojom

@@ -4,6 +4,7 @@
 
 module chrome.mojom;
 
+import "components/prerender/common/prerender_types.mojom";
 import "mojo/public/mojom/base/string16.mojom";
 import "third_party/blink/public/mojom/window_features/window_features.mojom";
 import "ui/gfx/geometry/mojom/geometry.mojom";
@@ -58,4 +59,10 @@ interface ChromeRenderFrame {
 
   // Requests the Media Feed Url from the renderer (if the page has one).
   GetMediaFeedURL() => (url.mojom.Url? url);
+
+  // Tells a renderer if it's currently being prerendered.  Must only be set
+  // before any navigation occurs, and only set to kNoPrerender at most once
+  // after that.
+  SetIsPrerendering(prerender.mojom.PrerenderMode mode,
+                    string histogram_prefix);
 };

chrome/renderer/BUILD.gn

@@ -94,6 +94,9 @@ static_library("renderer") {
     "plugins/plugin_uma.h",
     "prerender/prerender_helper.cc",
     "prerender/prerender_helper.h",
+    "prerender/prerender_observer.h",
+    "prerender/prerender_observer_list.cc",
+    "prerender/prerender_observer_list.h",
     "prerender/prerenderer_client.cc",
     "prerender/prerenderer_client.h",
     "previews/resource_loading_hints_agent.cc",

chrome/renderer/chrome_render_frame_observer.cc

@@ -25,6 +25,7 @@
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/media/media_feeds.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
+#include "chrome/renderer/prerender/prerender_observer_list.h"
 #include "chrome/renderer/web_apps.h"
 #include "components/crash/core/common/crash_key.h"
 #include "components/offline_pages/buildflags/buildflags.h"
@@ -126,6 +127,7 @@ ChromeRenderFrameObserver::ChromeRenderFrameObserver(
   render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
       base::Bind(&ChromeRenderFrameObserver::OnRenderFrameObserverRequest,
                  base::Unretained(this)));
+
   // Don't do anything else for subframes.
   if (!render_frame->IsMainFrame())
     return;
@@ -171,28 +173,6 @@ bool ChromeRenderFrameObserver::OnAssociatedInterfaceRequestForFrame(
   return associated_interfaces_.TryBindInterface(interface_name, handle);
 }
 
-bool ChromeRenderFrameObserver::OnMessageReceived(const IPC::Message& message) {
-  // Filter only.
-  bool handled = true;
-  // Messages in this message map have multiple handlers. Please do not add more
-  // messages here.
-  IPC_BEGIN_MESSAGE_MAP(ChromeRenderFrameObserver, message)
-    IPC_MESSAGE_HANDLER(PrerenderMsg_SetIsPrerendering, OnSetIsPrerendering)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  if (handled)
-    return false;
-
-  // Normal message handlers. Legacy IPC is deprecated, but leaving this as a
-  // placeholder in case new messages are added before legacy IPC handling is
-  // wholly removed from this class.
-  IPC_BEGIN_MESSAGE_MAP(ChromeRenderFrameObserver, message)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-
-  return handled;
-}
-
 void ChromeRenderFrameObserver::ReadyToCommitNavigation(
     WebDocumentLoader* document_loader) {
   // Execute cache clear operations that were postponed until a navigation
@@ -306,21 +286,28 @@ void ChromeRenderFrameObserver::OnDestruct() {
   delete this;
 }
 
-void ChromeRenderFrameObserver::OnSetIsPrerendering(
+void ChromeRenderFrameObserver::SetIsPrerendering(
     prerender::mojom::PrerenderMode mode,
     const std::string& histogram_prefix) {
-  if (mode != prerender::mojom::PrerenderMode::kNoPrerender) {
+  bool is_prerendering = mode != prerender::mojom::PrerenderMode::kNoPrerender;
+  if (is_prerendering) {
     // If the PrerenderHelper for this frame already exists, don't create it. It
     // can already be created for subframes during handling of
     // RenderFrameCreated, if the parent frame was prerendering at time of
     // subframe creation.
-    if (prerender::PrerenderHelper::Get(render_frame()))
-      return;
+    auto* prerender_helper = prerender::PrerenderHelper::Get(render_frame());
+    if (!prerender_helper) {
+      // The PrerenderHelper will destroy itself either after recording
+      // histograms or on destruction of the RenderView.
+      prerender_helper = new prerender::PrerenderHelper(render_frame(), mode,
+                                                        histogram_prefix);
+    }
 
-    // The PrerenderHelper will destroy itself either after recording histograms
-    // or on destruction of the RenderView.
-    new prerender::PrerenderHelper(render_frame(), mode, histogram_prefix);
+    prerender_helper->SetIsPrerendering(mode, histogram_prefix);
   }
+
+  prerender::PrerenderObserverList::SetIsPrerenderingForFrame(render_frame(),
+                                                              is_prerendering);
 }
 
 void ChromeRenderFrameObserver::SetWindowFeatures(

chrome/renderer/chrome_render_frame_observer.h

@@ -68,7 +68,6 @@ class ChromeRenderFrameObserver : public content::RenderFrameObserver,
   bool OnAssociatedInterfaceRequestForFrame(
       const std::string& interface_name,
       mojo::ScopedInterfaceEndpointHandle* handle) override;
-  bool OnMessageReceived(const IPC::Message& message) override;
   void ReadyToCommitNavigation(
       blink::WebDocumentLoader* document_loader) override;
   void DidFinishLoad() override;
@@ -78,10 +77,6 @@ class ChromeRenderFrameObserver : public content::RenderFrameObserver,
   void DidMeaningfulLayout(blink::WebMeaningfulLayout layout_type) override;
   void OnDestruct() override;
 
-  // IPC handlers
-  void OnSetIsPrerendering(prerender::mojom::PrerenderMode mode,
-                           const std::string& histogram_prefix);
-
   // chrome::mojom::ChromeRenderFrame:
   void SetWindowFeatures(
       blink::mojom::WindowFeaturesPtr window_features) override;
@@ -97,6 +92,8 @@ class ChromeRenderFrameObserver : public content::RenderFrameObserver,
   void SetCCTClientHeader(const std::string& header) override;
 #endif
   void GetMediaFeedURL(GetMediaFeedURLCallback callback) override;
+  void SetIsPrerendering(prerender::mojom::PrerenderMode mode,
+                         const std::string& histogram_prefix) override;
 
   // Initialize a |phishing_classifier_delegate_|.
   void SetClientSidePhishingDetection();

chrome/renderer/plugins/chrome_plugin_placeholder.cc

@@ -22,6 +22,7 @@
 #include "chrome/renderer/custom_menu_commands.h"
 #include "chrome/renderer/plugins/plugin_preroller.h"
 #include "chrome/renderer/plugins/plugin_uma.h"
+#include "chrome/renderer/prerender/prerender_observer_list.h"
 #include "components/content_settings/renderer/content_settings_agent_impl.h"
 #include "components/prerender/common/prerender_messages.h"
 #include "components/strings/grit/components_strings.h"
@@ -71,10 +72,14 @@ ChromePluginPlaceholder::ChromePluginPlaceholder(
       title_(title),
       context_menu_request_id_(0) {
   RenderThread::Get()->AddObserver(this);
+  prerender::PrerenderObserverList::AddObserverForFrame(render_frame, this);
 }
 
 ChromePluginPlaceholder::~ChromePluginPlaceholder() {
   RenderThread::Get()->RemoveObserver(this);
+  prerender::PrerenderObserverList::RemoveObserverForFrame(render_frame(),
+                                                           this);
+
   if (context_menu_request_id_ && render_frame())
     render_frame()->CancelContextMenu(context_menu_request_id_);
 }
@@ -180,7 +185,6 @@ bool ChromePluginPlaceholder::OnMessageReceived(const IPC::Message& message) {
   // We don't swallow these messages because multiple blocked plugins and other
   // objects have an interest in them.
   IPC_BEGIN_MESSAGE_MAP(ChromePluginPlaceholder, message)
-    IPC_MESSAGE_HANDLER(PrerenderMsg_SetIsPrerendering, OnSetPrerenderMode)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_LoadBlockedPlugins, OnLoadBlockedPlugins)
   IPC_END_MESSAGE_MAP()
 
@@ -211,10 +215,8 @@ void ChromePluginPlaceholder::UpdateFailure() {
                                         plugin_name_));
 }
 
-void ChromePluginPlaceholder::OnSetPrerenderMode(
-    prerender::mojom::PrerenderMode mode,
-    const std::string& histogram_prefix) {
-  OnSetIsPrerendering(mode != prerender::mojom::PrerenderMode::kNoPrerender);
+void ChromePluginPlaceholder::SetIsPrerendering(bool is_prerendering) {
+  OnSetIsPrerendering(is_prerendering);
 }
 
 void ChromePluginPlaceholder::PluginListChanged() {

chrome/renderer/plugins/chrome_plugin_placeholder.h

@@ -12,6 +12,7 @@
 #include "chrome/common/buildflags.h"
 #include "chrome/common/plugin.mojom.h"
 #include "chrome/renderer/plugins/power_saver_info.h"
+#include "chrome/renderer/prerender/prerender_observer.h"
 #include "components/plugins/renderer/loadable_plugin_placeholder.h"
 #include "components/prerender/common/prerender_types.mojom.h"
 #include "content/public/renderer/context_menu_client.h"
@@ -24,6 +25,7 @@ class ChromePluginPlaceholder final
       public content::RenderThreadObserver,
       public content::ContextMenuClient,
       public chrome::mojom::PluginRenderer,
+      public prerender::PrerenderObserver,
       public gin::Wrappable<ChromePluginPlaceholder> {
  public:
   static gin::WrapperInfo kWrapperInfo;
@@ -86,9 +88,8 @@ class ChromePluginPlaceholder final
   void UpdateSuccess() override;
   void UpdateFailure() override;
 
-  // IPC message handlers:
-  void OnSetPrerenderMode(prerender::mojom::PrerenderMode mode,
-                          const std::string& histogram_prefix);
+  // prerender::PrerenderObserver methods:
+  void SetIsPrerendering(bool is_prerendering) override;
 
   chrome::mojom::PluginStatus status_;
 

chrome/renderer/prerender/prerender_helper.cc

@@ -82,22 +82,12 @@ void PrerenderHelper::DidFinishDocumentLoad() {
     SendPrefetchFinished();
 }
 
-bool PrerenderHelper::OnMessageReceived(
-    const IPC::Message& message) {
-  IPC_BEGIN_MESSAGE_MAP(PrerenderHelper, message)
-    IPC_MESSAGE_HANDLER(PrerenderMsg_SetIsPrerendering, OnSetIsPrerendering)
-  IPC_END_MESSAGE_MAP()
-  // Return false on PrerenderMsg_SetIsPrerendering so other observers can see
-  // the message.
-  return false;
-}
-
 void PrerenderHelper::OnDestruct() {
   delete this;
 }
 
-void PrerenderHelper::OnSetIsPrerendering(prerender::mojom::PrerenderMode mode,
-                                          const std::string& histogram_prefix) {
+void PrerenderHelper::SetIsPrerendering(prerender::mojom::PrerenderMode mode,
+                                        const std::string& histogram_prefix) {
   // Immediately after construction, |this| may receive the message that
   // triggered its creation.  If so, ignore it.
   if (mode != prerender::mojom::PrerenderMode::kNoPrerender)

chrome/renderer/prerender/prerender_helper.h

@@ -48,15 +48,14 @@ class PrerenderHelper
   }
   std::string histogram_prefix() const { return histogram_prefix_; }
 
+  void SetIsPrerendering(prerender::mojom::PrerenderMode mode,
+                         const std::string& histogram_prefix);
+
  private:
   // RenderFrameObserver implementation.
   void DidFinishDocumentLoad() override;
-  bool OnMessageReceived(const IPC::Message& message) override;
   void OnDestruct() override;
 
-  void OnSetIsPrerendering(prerender::mojom::PrerenderMode mode,
-                           const std::string& histogram_prefix);
-
   void AddThrottle(const base::WeakPtr<PrerenderURLLoaderThrottle>& throttle);
   void OnThrottleDestroyed();
   void SendPrefetchFinished();

chrome/renderer/prerender/prerender_observer.h

+// Copyright 2020 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.
+
+#ifndef CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_H_
+#define CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_H_
+
+#include "base/observer_list_types.h"
+
+namespace prerender {
+
+class PrerenderObserver : public base::CheckedObserver {
+ public:
+  // Set prerendering mode for the plugin.
+  virtual void SetIsPrerendering(bool is_prerendering) = 0;
+
+ protected:
+  ~PrerenderObserver() override = default;
+};
+
+}  // namespace prerender
+
+#endif  // CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_H_

chrome/renderer/prerender/prerender_observer_list.cc

+// Copyright 2020 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.
+
+#include "chrome/renderer/prerender/prerender_observer_list.h"
+
+#include "chrome/renderer/prerender/prerender_observer.h"
+#include "content/public/renderer/render_frame.h"
+
+namespace prerender {
+
+namespace {
+
+// Key used to attach the handler to the RenderFrame.
+const char kPrerenderObserverListKey[] = "kPrerenderObserverListKey";
+
+}  // namespace
+
+// static
+void PrerenderObserverList::AddObserverForFrame(
+    content::RenderFrame* render_frame,
+    PrerenderObserver* observer) {
+  auto* observer_list = static_cast<PrerenderObserverList*>(
+      render_frame->GetUserData(kPrerenderObserverListKey));
+  if (!observer_list) {
+    observer_list = new PrerenderObserverList();
+    render_frame->SetUserData(kPrerenderObserverListKey,
+                              base::WrapUnique(observer_list));
+  }
+
+  observer_list->AddObserver(observer);
+}
+
+// static
+void PrerenderObserverList::RemoveObserverForFrame(
+    content::RenderFrame* render_frame,
+    PrerenderObserver* observer) {
+  auto* observer_list = static_cast<PrerenderObserverList*>(
+      render_frame->GetUserData(kPrerenderObserverListKey));
+  DCHECK(observer_list);
+
+  // Delete the PrerenderObserverList instance when the last observer is
+  // removed.
+  if (observer_list->RemoveObserver(observer))
+    render_frame->RemoveUserData(kPrerenderObserverListKey);
+}
+
+// static
+void PrerenderObserverList::SetIsPrerenderingForFrame(
+    content::RenderFrame* render_frame,
+    bool is_prerendering) {
+  auto* observer_list = static_cast<PrerenderObserverList*>(
+      render_frame->GetUserData(kPrerenderObserverListKey));
+  if (observer_list)
+    observer_list->SetIsPrerendering(is_prerendering);
+}
+
+PrerenderObserverList::PrerenderObserverList() = default;
+PrerenderObserverList::~PrerenderObserverList() = default;
+
+void PrerenderObserverList::AddObserver(PrerenderObserver* observer) {
+  prerender_observers_.AddObserver(observer);
+}
+
+bool PrerenderObserverList::RemoveObserver(PrerenderObserver* observer) {
+  prerender_observers_.RemoveObserver(observer);
+  return !prerender_observers_.might_have_observers();
+}
+
+void PrerenderObserverList::SetIsPrerendering(bool is_prerendering) {
+  for (auto& observer : prerender_observers_)
+    observer.SetIsPrerendering(is_prerendering);
+}
+
+}  // namespace prerender

chrome/renderer/prerender/prerender_observer_list.h

+// Copyright 2020 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.
+
+#ifndef CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_LIST_H_
+#define CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_LIST_H_
+
+#include "base/observer_list.h"
+#include "base/supports_user_data.h"
+
+namespace content {
+class RenderFrame;
+}
+
+namespace prerender {
+
+class PrerenderObserver;
+
+class PrerenderObserverList : public base::SupportsUserData::Data {
+ public:
+  static void AddObserverForFrame(content::RenderFrame* render_frame,
+                                  PrerenderObserver* observer);
+
+  static void RemoveObserverForFrame(content::RenderFrame* render_frame,
+                                     PrerenderObserver* observer);
+
+  static void SetIsPrerenderingForFrame(content::RenderFrame* render_frame,
+                                        bool is_prerendering);
+
+  PrerenderObserverList(const PrerenderObserverList&) = delete;
+  PrerenderObserverList& operator=(const PrerenderObserverList&) = delete;
+  ~PrerenderObserverList() override;
+
+ private:
+  PrerenderObserverList();
+
+  void AddObserver(PrerenderObserver* observer);
+
+  // Returns true if |prerender_observers_| is empty.
+  bool RemoveObserver(PrerenderObserver* observer);
+
+  void SetIsPrerendering(bool is_prerendering);
+
+  // All the registered observers for prerender.
+  base::ObserverList<prerender::PrerenderObserver> prerender_observers_;
+};
+
+}  // namespace prerender
+
+#endif  // CHROME_RENDERER_PRERENDER_PRERENDER_OBSERVER_LIST_H_

components/prerender/common/prerender_messages.h

@@ -5,31 +5,16 @@
 #ifndef COMPONENTS_PRERENDER_COMMON_PRERENDER_MESSAGES_H_
 #define COMPONENTS_PRERENDER_COMMON_PRERENDER_MESSAGES_H_
 
-#include "components/prerender/common/prerender_types.mojom.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_param_traits.h"
 
 #define IPC_MESSAGE_START PrerenderMsgStart
 
-IPC_ENUM_TRAITS_MAX_VALUE(prerender::mojom::PrerenderMode,
-                          prerender::mojom::PrerenderMode::kMaxValue)
-
 // PrerenderLinkManager Messages
 
 // Sent by the renderer process to notify that the resource prefetcher has
 // discovered all possible subresources and issued requests for them.
 IPC_MESSAGE_CONTROL0(PrerenderHostMsg_PrefetchFinished)
 
-// PrerenderDispatcher Messages
-// These are messages sent from the browser to the renderer in relation to
-// running prerenders.
-
-// Tells a renderer if it's currently being prerendered.  Must only be set
-// before any navigation occurs, and only set to NO_PRERENDER at most once after
-// that.
-IPC_MESSAGE_ROUTED2(PrerenderMsg_SetIsPrerendering,
-                    prerender::mojom::PrerenderMode,
-                    std::string /* histogram_prefix */)
-
 #endif  // COMPONENTS_PRERENDER_COMMON_PRERENDER_MESSAGES_H_

content/public/renderer/render_frame.h

@@ -13,6 +13,7 @@
 #include "base/callback_forward.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
+#include "base/supports_user_data.h"
 #include "content/common/content_export.h"
 #include "content/public/common/previews_state.h"
 #include "ipc/ipc_listener.h"
@@ -88,7 +89,8 @@ class AXTreeSnapshotter {
 // navigation. It provides communication with a corresponding RenderFrameHost
 // in the browser process.
 class CONTENT_EXPORT RenderFrame : public IPC::Listener,
-                                   public IPC::Sender {
+                                   public IPC::Sender,
+                                   public base::SupportsUserData {
  public:
   // These numeric values are used in UMA logs; do not change them.
   enum PeripheralContentStatus {