[fuchsia] Add a class to handle RenderFrame-lifespan-bound objects.

* Add a WebEngineRenderFrameObserver object whose lifespan is bound to
  the RenderFrame. This class owns other objects whose lifespand is
  also bound to the RenderFrame and that need to be accessed through
  WebEngineRenderContentClient.
* This is a preliminary refactor to add more objects to this class,
  particularly for the Cast Streaming Receiver.

Bug: 1042501
Change-Id: I1b8ba1de47be717e1ce28a3fcd40ebccb7a2f4e5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2209752
Commit-Queue: Fabrice de Gans-Riberi <fdegans@chromium.org>
Reviewed-by: David Dorwin <ddorwin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#772042}

fuchsia/engine/BUILD.gn

@@ -205,6 +205,8 @@ component("web_engine_core") {
     "renderer/url_request_rules_receiver.h",
     "renderer/web_engine_content_renderer_client.cc",
     "renderer/web_engine_content_renderer_client.h",
+    "renderer/web_engine_render_frame_observer.cc",
+    "renderer/web_engine_render_frame_observer.h",
     "renderer/web_engine_url_loader_throttle_provider.cc",
     "renderer/web_engine_url_loader_throttle_provider.h",
     "url_request_rewrite_type_converters.cc",

fuchsia/engine/renderer/url_request_rules_receiver.cc

@@ -11,13 +11,8 @@
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
 
 UrlRequestRulesReceiver::UrlRequestRulesReceiver(
-    content::RenderFrame* render_frame,
-    base::OnceCallback<void(int)> on_render_frame_deleted_callback)
-    : content::RenderFrameObserver(render_frame),
-      on_render_frame_deleted_callback_(
-          std::move(on_render_frame_deleted_callback)) {
+    content::RenderFrame* render_frame) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK(on_render_frame_deleted_callback_);
   DCHECK(render_frame);
 
   // It is fine to use an unretained pointer to |this| here as the
@@ -54,12 +49,3 @@ UrlRequestRulesReceiver::GetCachedRules() {
   base::AutoLock auto_lock(lock_);
   return cached_rules_;
 }
-
-void UrlRequestRulesReceiver::OnDestruct() {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-
-  // The RenderFrame corresponding to this object was destroyed, which means
-  // the AssociatedInterfaceRegsitry is also gone. It is expected that
-  // |on_render_frame_deleted_callback_| will delete |this|.
-  std::move(on_render_frame_deleted_callback_).Run(routing_id());
-}

fuchsia/engine/renderer/url_request_rules_receiver.h

@@ -19,22 +19,18 @@ namespace content {
 class RenderFrame;
 }  // namespace content
 
-// Provides rewriting rules for network requests. UrlRequestRulesReceiver
-// objects are owned by their respective WebEngineContentRendererClient and they
-// will be destroyed on RenderFrame destruction. This is guaranteed to outlive
-// any WebEngineURLLoaderThrottle that uses it as the RenderFrame destruction
-// will have triggered the destruction of all pending
-// WebEngineURLLoaderThrottles.
+// Provides rewriting rules for network requests. Owned by
+// WebEngineRenderFrameObserver, this object will be destroyed on RenderFrame
+// destruction. This is guaranteed to outlive any WebEngineURLLoaderThrottle
+// that uses it as the RenderFrame destruction will have triggered the
+// destruction of all pending WebEngineURLLoaderThrottles.
 // This class should only be used on the IO thread, with the exception of the
 // GetCachedRules() implementation, which can be called from any sequence.
 class UrlRequestRulesReceiver
     : public mojom::UrlRequestRulesReceiver,
-      public WebEngineURLLoaderThrottle::CachedRulesProvider,
-      public content::RenderFrameObserver {
+      public WebEngineURLLoaderThrottle::CachedRulesProvider {
  public:
-  UrlRequestRulesReceiver(
-      content::RenderFrame* render_frame,
-      base::OnceCallback<void(int)> on_render_frame_deleted_callback);
+  UrlRequestRulesReceiver(content::RenderFrame* render_frame);
   ~UrlRequestRulesReceiver() override;
 
  private:
@@ -48,9 +44,6 @@ class UrlRequestRulesReceiver
   scoped_refptr<WebEngineURLLoaderThrottle::UrlRequestRewriteRules>
   GetCachedRules() override;
 
-  // content::RenderFrameObserver implementation.
-  void OnDestruct() override;
-
   base::Lock lock_;
 
   // This is accessed by WebEngineURLLoaderThrottles, which can be off-sequence
@@ -61,7 +54,6 @@ class UrlRequestRulesReceiver
   mojo::AssociatedReceiver<mojom::UrlRequestRulesReceiver>
       url_request_rules_receiver_{this};
 
-  base::OnceCallback<void(int)> on_render_frame_deleted_callback_;
   SEQUENCE_CHECKER(sequence_checker_);
 
   DISALLOW_COPY_AND_ASSIGN(UrlRequestRulesReceiver);

fuchsia/engine/renderer/web_engine_content_renderer_client.cc

@@ -110,16 +110,16 @@ WebEngineContentRendererClient::WebEngineContentRendererClient() = default;
 
 WebEngineContentRendererClient::~WebEngineContentRendererClient() = default;
 
-UrlRequestRulesReceiver*
-WebEngineContentRendererClient::GetUrlRequestRulesReceiverForRenderFrameId(
+WebEngineRenderFrameObserver*
+WebEngineContentRendererClient::GetWebEngineRenderFrameObserverForRenderFrameId(
     int render_frame_id) const {
-  auto iter = url_request_receivers_by_id_.find(render_frame_id);
-  DCHECK(iter != url_request_receivers_by_id_.end());
+  auto iter = render_frame_id_to_observer_map_.find(render_frame_id);
+  DCHECK(iter != render_frame_id_to_observer_map_.end());
   return iter->second.get();
 }
 
 void WebEngineContentRendererClient::OnRenderFrameDeleted(int render_frame_id) {
-  size_t count = url_request_receivers_by_id_.erase(render_frame_id);
+  size_t count = render_frame_id_to_observer_map_.erase(render_frame_id);
   DCHECK_EQ(count, 1u);
 }
 
@@ -130,13 +130,14 @@ void WebEngineContentRendererClient::RenderFrameCreated(
   new OnLoadScriptInjector(render_frame);
 
   int render_frame_id = render_frame->GetRoutingID();
-  auto rules_receiver = std::make_unique<UrlRequestRulesReceiver>(
-      content::RenderFrame::FromRoutingID(render_frame_id),
+
+  auto render_frame_observer = std::make_unique<WebEngineRenderFrameObserver>(
+      render_frame,
       base::BindOnce(&WebEngineContentRendererClient::OnRenderFrameDeleted,
                      base::Unretained(this)));
-  auto iter = url_request_receivers_by_id_.emplace(render_frame_id,
-                                                   std::move(rules_receiver));
-  DCHECK(iter.second);
+  auto render_frame_observer_iter = render_frame_id_to_observer_map_.emplace(
+      render_frame_id, std::move(render_frame_observer));
+  DCHECK(render_frame_observer_iter.second);
 
   // Lifetime is tied to |render_frame| via content::RenderFrameObserver.
   new media_control::MediaPlaybackOptions(render_frame);

fuchsia/engine/renderer/web_engine_content_renderer_client.h

@@ -7,20 +7,21 @@
 
 #include "base/macros.h"
 #include "content/public/renderer/content_renderer_client.h"
-#include "fuchsia/engine/renderer/url_request_rules_receiver.h"
+#include "fuchsia/engine/renderer/web_engine_render_frame_observer.h"
 
 class WebEngineContentRendererClient : public content::ContentRendererClient {
  public:
   WebEngineContentRendererClient();
   ~WebEngineContentRendererClient() override;
 
-  // Returns the UrlRequestRulesReceiver corresponding to |render_frame_id|.
-  UrlRequestRulesReceiver* GetUrlRequestRulesReceiverForRenderFrameId(
+  // Returns the WebEngineRenderFrameObserver corresponding to
+  // |render_frame_id|.
+  WebEngineRenderFrameObserver* GetWebEngineRenderFrameObserverForRenderFrameId(
       int render_frame_id) const;
 
  private:
-  // Called by UrlRequestRulesReceivers when their corresponding RenderFrame is
-  // in the process of being deleted.
+  // Called by WebEngineRenderFrameObserver when its corresponding RenderFrame
+  // is in the process of being deleted.
   void OnRenderFrameDeleted(int render_frame_id);
 
   // content::ContentRendererClient overrides.
@@ -39,9 +40,9 @@ class WebEngineContentRendererClient : public content::ContentRendererClient {
   bool RunClosureWhenInForeground(content::RenderFrame* render_frame,
                                   base::OnceClosure closure);
 
-  // Map of rules receivers per RenderFrame ID.
-  std::map<int, std::unique_ptr<UrlRequestRulesReceiver>>
-      url_request_receivers_by_id_;
+  // Map of RenderFrame ID to WebEngineRenderFrameObserver.
+  std::map<int, std::unique_ptr<WebEngineRenderFrameObserver>>
+      render_frame_id_to_observer_map_;
 
   DISALLOW_COPY_AND_ASSIGN(WebEngineContentRendererClient);
 };

fuchsia/engine/renderer/web_engine_render_frame_observer.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 "fuchsia/engine/renderer/web_engine_render_frame_observer.h"
+
+#include "content/public/renderer/render_frame.h"
+
+WebEngineRenderFrameObserver::WebEngineRenderFrameObserver(
+    content::RenderFrame* render_frame,
+    base::OnceCallback<void(int)> on_render_frame_deleted_callback)
+    : content::RenderFrameObserver(render_frame),
+      url_request_rules_receiver_(render_frame),
+      on_render_frame_deleted_callback_(
+          std::move(on_render_frame_deleted_callback)) {
+  DCHECK(render_frame);
+  DCHECK(on_render_frame_deleted_callback_);
+}
+
+WebEngineRenderFrameObserver::~WebEngineRenderFrameObserver() = default;
+
+void WebEngineRenderFrameObserver::OnDestruct() {
+  std::move(on_render_frame_deleted_callback_).Run(routing_id());
+}

fuchsia/engine/renderer/web_engine_render_frame_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 FUCHSIA_ENGINE_RENDERER_WEB_ENGINE_RENDER_FRAME_OBSERVER_H_
+#define FUCHSIA_ENGINE_RENDERER_WEB_ENGINE_RENDER_FRAME_OBSERVER_H_
+
+#include "base/callback.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "fuchsia/engine/renderer/url_request_rules_receiver.h"
+
+namespace content {
+class RenderFrame;
+}  // namespace content
+
+// This class owns WebEngine-specific objects whose lifespan is tied to a
+// RenderFrame. Owned by WebEngineContentRendererClient, this object will be
+// destroyed on RenderFrame destruction, triggering the destruction of all of
+// the objects it exposes.
+class WebEngineRenderFrameObserver : public content::RenderFrameObserver {
+ public:
+  // |on_render_frame_deleted_callback| must delete |this|.
+  WebEngineRenderFrameObserver(
+      content::RenderFrame* render_frame,
+      base::OnceCallback<void(int)> on_render_frame_deleted_callback);
+  ~WebEngineRenderFrameObserver() final;
+
+  WebEngineRenderFrameObserver(const WebEngineRenderFrameObserver&) = delete;
+  WebEngineRenderFrameObserver& operator=(const WebEngineRenderFrameObserver&) =
+      delete;
+
+  UrlRequestRulesReceiver* url_request_rules_receiver() {
+    return &url_request_rules_receiver_;
+  }
+
+ private:
+  // content::RenderFrameObserver implementation.
+  void OnDestruct() final;
+
+  UrlRequestRulesReceiver url_request_rules_receiver_;
+
+  base::OnceCallback<void(int)> on_render_frame_deleted_callback_;
+};
+
+#endif  // FUCHSIA_ENGINE_RENDERER_WEB_ENGINE_RENDER_FRAME_OBSERVER_H_

fuchsia/engine/renderer/web_engine_url_loader_throttle_provider.cc

@@ -33,8 +33,9 @@ WebEngineURLLoaderThrottleProvider::CreateThrottles(
 
   std::vector<std::unique_ptr<blink::URLLoaderThrottle>> throttles;
   throttles.emplace_back(std::make_unique<WebEngineURLLoaderThrottle>(
-      content_renderer_client_->GetUrlRequestRulesReceiverForRenderFrameId(
-          render_frame_id)));
+      content_renderer_client_
+          ->GetWebEngineRenderFrameObserverForRenderFrameId(render_frame_id)
+          ->url_request_rules_receiver()));
   return throttles;
 }