Prerender: Rename PrerenderHandleClient to PrerenderProcessorClient

This is a follow-up CL for https://crrev.com/c/2413830. After the CL,
mojom::PrerenderHandleClient was the client of mojom::PrerenderProcessor
so that should have been renamed to mojom::PrerenderProcessorClient.

Bug: 1132746
Change-Id: Ia55cbf2f0e248baf3f172caeccbd29be18f3f614
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2434071Reviewed-by: Robert Ogden <robertogden@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Hiroki Nakagawa <nhiroki@chromium.org>
Cr-Commit-Position: refs/heads/master@{#811386}

chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc

@@ -407,7 +407,7 @@ class NoStatePrefetchBrowserTest
   }
 
   // Synchronization note: The IPCs used to communicate DOM events back to the
-  // referring web page (see blink::mojom::PrerenderHandleClient) may race w/
+  // referring web page (see blink::mojom::PrerenderProcessorClient) may race w/
   // the IPCs used here to inject script. The WaitFor* variants should be used
   // when an event was expected to happen or to happen soon.
 

chrome/browser/prerender/prerender_unittest.cc

@@ -68,12 +68,13 @@ class UnitTestPrerenderManager;
 
 namespace {
 
-class DummyPrerenderHandleClient : public blink::mojom::PrerenderHandleClient {
+class DummyPrerenderProcessorClient
+    : public blink::mojom::PrerenderProcessorClient {
  public:
-  DummyPrerenderHandleClient() = default;
-  ~DummyPrerenderHandleClient() override = default;
+  DummyPrerenderProcessorClient() = default;
+  ~DummyPrerenderProcessorClient() override = default;
 
-  // blink::mojom::PrerenderHandleClient implementation
+  // blink::mojom::PrerenderProcessorClient implementation
   void OnPrerenderStart() override {}
   void OnPrerenderStopLoading() override {}
   void OnPrerenderDomContentLoaded() override {}
@@ -406,15 +407,16 @@ class PrerenderTest : public testing::Test {
     attributes->initiator_origin = url::Origin::Create(initiator_url);
     attributes->view_size = kDefaultViewSize;
 
-    mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client;
-    clients_.Add(std::make_unique<DummyPrerenderHandleClient>(),
-                 handle_client.InitWithNewPipeAndPassReceiver());
+    mojo::PendingRemote<blink::mojom::PrerenderProcessorClient>
+        processor_client;
+    clients_.Add(std::make_unique<DummyPrerenderProcessorClient>(),
+                 processor_client.InitWithNewPipeAndPassReceiver());
 
     // This could delete an existing prerender as a side-effect.
     base::Optional<int> prerender_id =
         prerender_link_manager()->OnStartPrerender(
             render_process_id, render_view_id, std::move(attributes),
-            std::move(handle_client));
+            std::move(processor_client));
 
     // Check if the new prerender request was added and running.
     return prerender_id && LastPrerenderIsRunning();
@@ -473,7 +475,7 @@ class PrerenderTest : public testing::Test {
         chrome_browser_net::NETWORK_PREDICTION_ALWAYS);
   }
 
-  void DisconnectAllPrerenderHandleClients() { clients_.Clear(); }
+  void DisconnectAllPrerenderProcessorClients() { clients_.Clear(); }
 
   const base::HistogramTester& histogram_tester() { return histogram_tester_; }
 
@@ -486,7 +488,7 @@ class PrerenderTest : public testing::Test {
   std::unique_ptr<UnitTestPrerenderManager> prerender_manager_;
   std::unique_ptr<PrerenderLinkManager> prerender_link_manager_;
   base::HistogramTester histogram_tester_;
-  mojo::UniqueReceiverSet<blink::mojom::PrerenderHandleClient> clients_;
+  mojo::UniqueReceiverSet<blink::mojom::PrerenderProcessorClient> clients_;
 
   // Restore prerender mode after this test finishes running.
   test_utils::RestorePrerenderMode restore_prerender_mode_;
@@ -1599,7 +1601,7 @@ TEST_F(PrerenderTest, LinkManagerRendererDisconnect) {
 
   // Disconnect all clients. Spin the run loop to give the link manager
   // opportunity to detect disconnection.
-  DisconnectAllPrerenderHandleClients();
+  DisconnectAllPrerenderProcessorClients();
   base::RunLoop().RunUntilIdle();
 
   tick_clock()->Advance(prerender_manager()->config().abandon_time_to_live +

components/prerender/browser/prerender_link_manager.cc

@@ -52,7 +52,8 @@ PrerenderLinkManager::LinkPrerender::LinkPrerender(
     int launcher_render_process_id,
     int launcher_render_view_id,
     blink::mojom::PrerenderAttributesPtr attributes,
-    mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client,
+    mojo::PendingRemote<blink::mojom::PrerenderProcessorClient>
+        processor_client,
     base::TimeTicks creation_time,
     PrerenderContents* deferred_launcher)
     : launcher_render_process_id(launcher_render_process_id),
@@ -62,7 +63,7 @@ PrerenderLinkManager::LinkPrerender::LinkPrerender(
       referrer(content::Referrer(*attributes->referrer)),
       initiator_origin(attributes->initiator_origin),
       size(attributes->view_size),
-      remote_handle_client(std::move(handle_client)),
+      remote_processor_client(std::move(processor_client)),
       creation_time(creation_time),
       deferred_launcher(deferred_launcher),
       has_been_abandoned(false),
@@ -91,7 +92,8 @@ base::Optional<int> PrerenderLinkManager::OnStartPrerender(
     int launcher_render_process_id,
     int launcher_render_view_id,
     blink::mojom::PrerenderAttributesPtr attributes,
-    mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client) {
+    mojo::PendingRemote<blink::mojom::PrerenderProcessorClient>
+        processor_client) {
 // TODO(crbug.com/722453): Use a dedicated build flag for GuestView.
 #if !defined(OS_ANDROID) && !defined(OS_IOS) && !defined(OS_FUCHSIA)
   content::RenderViewHost* rvh = content::RenderViewHost::FromID(
@@ -118,13 +120,13 @@ base::Optional<int> PrerenderLinkManager::OnStartPrerender(
 
   auto prerender = std::make_unique<LinkPrerender>(
       launcher_render_process_id, launcher_render_view_id,
-      std::move(attributes), std::move(handle_client),
+      std::move(attributes), std::move(processor_client),
       manager_->GetCurrentTimeTicks(), prerender_contents);
 
   // Observe disconnect of the client and treat as equivalent to explicit
   // abandonment. Similar to above, the raw pointer to |this| is safe because
   // |prerender| is owned by |this|.
-  prerender->remote_handle_client.set_disconnect_handler(
+  prerender->remote_processor_client.set_disconnect_handler(
       base::BindOnce(&PrerenderLinkManager::OnAbandonPrerender,
                      base::Unretained(this), prerender->prerender_id));
 
@@ -290,7 +292,7 @@ void PrerenderLinkManager::StartPrerenders() {
       running_launcher_and_render_view_routes.insert(
           launcher_and_render_view_route);
     } else {
-      pending_prerender->remote_handle_client->OnPrerenderStop();
+      pending_prerender->remote_processor_client->OnPrerenderStop();
       prerenders_.erase(it);
     }
   }
@@ -354,7 +356,7 @@ void PrerenderLinkManager::OnPrerenderStart(PrerenderHandle* prerender_handle) {
   if (!prerender)
     return;
 
-  prerender->remote_handle_client->OnPrerenderStart();
+  prerender->remote_processor_client->OnPrerenderStart();
 }
 
 void PrerenderLinkManager::OnPrerenderStopLoading(
@@ -363,7 +365,7 @@ void PrerenderLinkManager::OnPrerenderStopLoading(
   if (!prerender)
     return;
 
-  prerender->remote_handle_client->OnPrerenderStopLoading();
+  prerender->remote_processor_client->OnPrerenderStopLoading();
 }
 
 void PrerenderLinkManager::OnPrerenderDomContentLoaded(
@@ -372,7 +374,7 @@ void PrerenderLinkManager::OnPrerenderDomContentLoaded(
   if (!prerender)
     return;
 
-  prerender->remote_handle_client->OnPrerenderDomContentLoaded();
+  prerender->remote_processor_client->OnPrerenderDomContentLoaded();
 }
 
 void PrerenderLinkManager::OnPrerenderStop(PrerenderHandle* prerender_handle) {
@@ -380,7 +382,7 @@ void PrerenderLinkManager::OnPrerenderStop(PrerenderHandle* prerender_handle) {
   if (!prerender)
     return;
 
-  prerender->remote_handle_client->OnPrerenderStop();
+  prerender->remote_processor_client->OnPrerenderStop();
 
   RemovePrerender(prerender);
   StartPrerenders();

components/prerender/browser/prerender_link_manager.h

@@ -44,7 +44,8 @@ class PrerenderLinkManager : public KeyedService,
       int launcher_render_process_id,
       int launcher_render_view_id,
       blink::mojom::PrerenderAttributesPtr attributes,
-      mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client);
+      mojo::PendingRemote<blink::mojom::PrerenderProcessorClient>
+          processor_client);
 
   // Called when a <link rel=prerender ...> element has been explicitly removed
   // from a document.
@@ -66,13 +67,13 @@ class PrerenderLinkManager : public KeyedService,
 
   // Used to store state about a requested prerender.
   struct LinkPrerender {
-    LinkPrerender(
-        int launcher_render_process_id,
-        int launcher_render_view_id,
-        blink::mojom::PrerenderAttributesPtr attributes,
-        mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client,
-        base::TimeTicks creation_time,
-        PrerenderContents* deferred_launcher);
+    LinkPrerender(int launcher_render_process_id,
+                  int launcher_render_view_id,
+                  blink::mojom::PrerenderAttributesPtr attributes,
+                  mojo::PendingRemote<blink::mojom::PrerenderProcessorClient>
+                      processor_client,
+                  base::TimeTicks creation_time,
+                  PrerenderContents* deferred_launcher);
     ~LinkPrerender();
 
     LinkPrerender(const LinkPrerender& other) = delete;
@@ -88,7 +89,8 @@ class PrerenderLinkManager : public KeyedService,
     const gfx::Size size;
 
     // Notification interface back to the requestor of this prerender.
-    mojo::Remote<blink::mojom::PrerenderHandleClient> remote_handle_client;
+    mojo::Remote<blink::mojom::PrerenderProcessorClient>
+        remote_processor_client;
 
     // The time at which this Prerender was added to PrerenderLinkManager.
     const base::TimeTicks creation_time;

components/prerender/browser/prerender_processor_impl.cc

@@ -38,7 +38,7 @@ void PrerenderProcessorImpl::Create(
 
 void PrerenderProcessorImpl::Start(
     blink::mojom::PrerenderAttributesPtr attributes,
-    mojo::PendingRemote<blink::mojom::PrerenderHandleClient> handle_client) {
+    mojo::PendingRemote<blink::mojom::PrerenderProcessorClient> client) {
   if (!attributes->initiator_origin.opaque() &&
       !content::ChildProcessSecurityPolicy::GetInstance()
            ->CanAccessDataForOrigin(render_process_id_,
@@ -66,7 +66,7 @@ void PrerenderProcessorImpl::Start(
   prerender_id_ = link_manager->OnStartPrerender(
       render_process_id_,
       render_frame_host->GetRenderViewHost()->GetRoutingID(),
-      std::move(attributes), std::move(handle_client));
+      std::move(attributes), std::move(client));
 }
 
 void PrerenderProcessorImpl::Cancel() {

components/prerender/browser/prerender_processor_impl.h

@@ -28,9 +28,9 @@ class PrerenderProcessorImpl : public blink::mojom::PrerenderProcessor {
       std::unique_ptr<PrerenderProcessorImplDelegate> delegate);
 
   // blink::mojom::PrerenderProcessor implementation
-  void Start(
-      blink::mojom::PrerenderAttributesPtr attributes,
-      mojo::PendingRemote<blink::mojom::PrerenderHandleClient> client) override;
+  void Start(blink::mojom::PrerenderAttributesPtr attributes,
+             mojo::PendingRemote<blink::mojom::PrerenderProcessorClient> client)
+      override;
   void Cancel() override;
   void Abandon() override;
 

third_party/blink/public/mojom/prerender/prerender.mojom

@@ -9,14 +9,11 @@ import "ui/gfx/geometry/mojom/geometry.mojom";
 import "url/mojom/origin.mojom";
 import "url/mojom/url.mojom";
 
-// This interface is used to notify of events on prerendering from the browser
-// process to a renderer process that requested prerendering. This is created
-// per prerender request, for example, when a new <link rel=prerender> element
-// is added, when the element's href is changed, etc.
-//
-// TODO(https://crbug.com/1126305): Rename this interface to
-// PrerenderProcessorClient.
-interface PrerenderHandleClient {
+// This interface is used to notify of events about prerendering from the
+// browser process to a renderer process that requested prerendering. This is
+// created per prerender request, for example, when a new <link rel=prerender>
+// element is added, when the element's href is changed, etc.
+interface PrerenderProcessorClient {
   // Notifies that a prerender started.
   OnPrerenderStart();
 
@@ -52,16 +49,16 @@ struct PrerenderAttributes {
 // changed, etc.
 interface PrerenderProcessor {
   // Requests the browesr process to start prerendering with
-  // |prerender_attribute|. |prerender_handle_client| will be notified as the
+  // |prerender_attribute|. |prerender_processor_client| will be notified as the
   // prerendering makes progress. This must be called only one time before any
   // other functions.
   Start(PrerenderAttributes prerender_attribute,
-        pending_remote<PrerenderHandleClient> prerender_handle_client);
+        pending_remote<PrerenderProcessorClient> prerender_processor_client);
 
   // Cancels the ongoing prerendering. This is supposed to be called when the
   // <link rel=prerender> element is removed, the element's href is changed,
   // etc. This must be called after Start(). This does not trigger
-  // OnPrerenderStop() on PrerenderHandleClient.
+  // OnPrerenderStop() on PrerenderProcessorClient.
   Cancel();
 
   // Abandons the ongoing prerendering. This is supposed to be called when the

third_party/blink/renderer/core/loader/prerender_test.cc

@@ -77,7 +77,7 @@ class MockPrerenderProcessor : public mojom::blink::PrerenderProcessor {
 
   // mojom::blink::PrerenderProcessor implementation
   void Start(mojom::blink::PrerenderAttributesPtr attributes,
-             mojo::PendingRemote<mojom::blink::PrerenderHandleClient> client)
+             mojo::PendingRemote<mojom::blink::PrerenderProcessorClient> client)
       override {
     attributes_ = std::move(attributes);
     client_.Bind(std::move(client));
@@ -118,7 +118,7 @@ class MockPrerenderProcessor : public mojom::blink::PrerenderProcessor {
 
  private:
   mojom::blink::PrerenderAttributesPtr attributes_;
-  mojo::Remote<mojom::blink::PrerenderHandleClient> client_;
+  mojo::Remote<mojom::blink::PrerenderProcessorClient> client_;
   mojo::Receiver<mojom::blink::PrerenderProcessor> receiver_{this};
 
   size_t cancel_count_ = 0;

third_party/blink/renderer/core/loader/private/prerender_handle.cc

@@ -71,12 +71,12 @@ PrerenderHandle* PrerenderHandle::Create(
       prerender_processor.BindNewPipeAndPassReceiver(
           context->GetTaskRunner(TaskType::kMiscPlatformAPI)));
 
-  mojo::PendingRemote<mojom::blink::PrerenderHandleClient>
-      prerender_handle_client;
-  auto receiver = prerender_handle_client.InitWithNewPipeAndPassReceiver();
+  mojo::PendingRemote<mojom::blink::PrerenderProcessorClient>
+      prerender_processor_client;
+  auto receiver = prerender_processor_client.InitWithNewPipeAndPassReceiver();
 
   prerender_processor->Start(std::move(attributes),
-                             std::move(prerender_handle_client));
+                             std::move(prerender_processor_client));
 
   return MakeGarbageCollected<PrerenderHandle>(PassKey(), context, client, url,
                                                std::move(prerender_processor),
@@ -89,7 +89,7 @@ PrerenderHandle::PrerenderHandle(
     PrerenderClient* client,
     const KURL& url,
     HeapMojoRemote<mojom::blink::PrerenderProcessor> remote_processor,
-    mojo::PendingReceiver<mojom::blink::PrerenderHandleClient> receiver)
+    mojo::PendingReceiver<mojom::blink::PrerenderProcessorClient> receiver)
     : ExecutionContextLifecycleObserver(context),
       url_(url),
       client_(client),

third_party/blink/renderer/core/loader/private/prerender_handle.h

@@ -47,9 +47,16 @@ class ExecutionContext;
 class Document;
 class PrerenderClient;
 
+// This is the Blink-side liaison of mojom::PrerenderProcessor to request the
+// browser process to start prerendering, and implements
+// mojom::PrerenderProcessorClient to observe events about prerendering. This is
+// instantiated per prerender request, for example, when a new <link
+// rel=prerender> element is added, when the element's href is changed etc.
+//
+// TODO(https://crbug.com/1126305): Rename this to PrerenderProcessorHandle.
 class PrerenderHandle final : public GarbageCollected<PrerenderHandle>,
                               public ExecutionContextLifecycleObserver,
-                              public mojom::blink::PrerenderHandleClient {
+                              public mojom::blink::PrerenderProcessorClient {
   USING_PRE_FINALIZER(PrerenderHandle, Dispose);
 
  public:
@@ -60,12 +67,13 @@ class PrerenderHandle final : public GarbageCollected<PrerenderHandle>,
       mojom::blink::PrerenderRelType prerender_rel_type);
 
   using PassKey = util::PassKey<PrerenderHandle>;
-  PrerenderHandle(PassKey,
-                  ExecutionContext*,
-                  PrerenderClient*,
-                  const KURL&,
-                  HeapMojoRemote<mojom::blink::PrerenderProcessor>,
-                  mojo::PendingReceiver<mojom::blink::PrerenderHandleClient>);
+  PrerenderHandle(
+      PassKey,
+      ExecutionContext*,
+      PrerenderClient*,
+      const KURL&,
+      HeapMojoRemote<mojom::blink::PrerenderProcessor>,
+      mojo::PendingReceiver<mojom::blink::PrerenderProcessorClient>);
   ~PrerenderHandle() override;
   void Dispose();
 
@@ -75,7 +83,7 @@ class PrerenderHandle final : public GarbageCollected<PrerenderHandle>,
   // ExecutionContextLifecycleObserver:
   void ContextDestroyed() override;
 
-  // mojom::blink::PrerenderHandleClient:
+  // mojom::blink::PrerenderProcessorClient:
   void OnPrerenderStart() override;
   void OnPrerenderStopLoading() override;
   void OnPrerenderDomContentLoaded() override;
@@ -89,7 +97,7 @@ class PrerenderHandle final : public GarbageCollected<PrerenderHandle>,
   KURL url_;
   WeakMember<PrerenderClient> client_;
   HeapMojoRemote<mojom::blink::PrerenderProcessor> remote_processor_;
-  HeapMojoReceiver<mojom::blink::PrerenderHandleClient, PrerenderHandle>
+  HeapMojoReceiver<mojom::blink::PrerenderProcessorClient, PrerenderHandle>
       receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(PrerenderHandle);