NoStatePrefetch: Rename PrerenderHelper to NoStatePrefetchHelper

In addition, this CL renames PrerenderHelper::IsPrerendering() to
NoStatePrefetchHelper::IsPrefetching().

Bug: 1144577
Change-Id: I1e875f651c50f401c54c7cc8d60d0b508b8e9ff7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626671
Commit-Queue: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843481}

chrome/renderer/chrome_content_renderer_client.cc

@@ -89,7 +89,7 @@
 #include "components/network_hints/renderer/web_prescient_networking_impl.h"
 #include "components/no_state_prefetch/common/prerender_url_loader_throttle.h"
 #include "components/no_state_prefetch/renderer/no_state_prefetch_client.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/no_state_prefetch/renderer/prerender_render_frame_observer.h"
 #include "components/no_state_prefetch/renderer/prerender_utils.h"
 #include "components/page_load_metrics/renderer/metrics_render_frame_observer.h"
@@ -534,13 +534,15 @@ void ChromeContentRendererClient::RenderFrameCreated(
 #endif
 
   if (!render_frame->IsMainFrame()) {
-    auto* prerender_helper = prerender::PrerenderHelper::Get(
+    auto* main_frame_no_state_prefetch_helper =
+        prerender::NoStatePrefetchHelper::Get(
             render_frame->GetRenderView()->GetMainRenderFrame());
-    if (prerender_helper) {
+    if (main_frame_no_state_prefetch_helper) {
       // Avoid any race conditions from having the browser tell subframes that
-      // they're prerendering.
-      new prerender::PrerenderHelper(render_frame,
-                                     prerender_helper->histogram_prefix());
+      // they're no-state prefetching.
+      new prerender::NoStatePrefetchHelper(
+          render_frame,
+          main_frame_no_state_prefetch_helper->histogram_prefix());
     }
   }
 
@@ -955,19 +957,19 @@ WebPlugin* ChromeContentRendererClient::CreatePlugin(
                   : PDFLoadStatus::kLoadedEmbeddedPdfWithPdfium);
         }
 
-        // Delay loading plugins if prerendering.
-        // TODO(mmenke):  In the case of prerendering, feed into
+        // Delay loading plugins if no-state prefetching.
+        // TODO(mmenke):  In the case of NoStatePrefetch, feed into
         //                ChromeContentRendererClient::CreatePlugin instead, to
         //                reduce the chance of future regressions.
-        bool is_prerendering =
-            prerender::PrerenderHelper::IsPrerendering(render_frame);
+        bool is_no_state_prefetching =
+            prerender::NoStatePrefetchHelper::IsPrefetching(render_frame);
 
-        if (is_prerendering) {
+        if (is_no_state_prefetching) {
           placeholder = ChromePluginPlaceholder::CreateBlockedPlugin(
               render_frame, params, info, identifier, group_name,
               IDR_BLOCKED_PLUGIN_HTML,
               l10n_util::GetStringFUTF16(IDS_PLUGIN_BLOCKED, group_name));
-          placeholder->set_blocked_for_prerendering(is_prerendering);
+          placeholder->set_blocked_for_prerendering(is_no_state_prefetching);
           placeholder->AllowLoading();
           break;
         }
@@ -1311,7 +1313,7 @@ void ChromeContentRendererClient::WillSendRequest(
 
 bool ChromeContentRendererClient::IsPrefetchOnly(
     content::RenderFrame* render_frame) {
-  return prerender::PrerenderHelper::IsPrerendering(render_frame);
+  return prerender::NoStatePrefetchHelper::IsPrefetching(render_frame);
 }
 
 uint64_t ChromeContentRendererClient::VisitedLinkHash(const char* canonical_url,

chrome/renderer/chrome_render_frame_observer.cc

@@ -27,7 +27,7 @@
 #include "chrome/renderer/media/media_feeds.h"
 #include "chrome/renderer/web_page_metadata_extraction.h"
 #include "components/crash/core/common/crash_key.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/offline_pages/buildflags/buildflags.h"
 #include "components/translate/content/renderer/translate_agent.h"
 #include "components/translate/core/common/translate_util.h"
@@ -489,8 +489,8 @@ void ChromeRenderFrameObserver::CapturePageText(TextCaptureType capture_type) {
   if (document_loader && document_loader->HasUnreachableURL())
     return;
 
-  // Don't index/capture pages that are being prerendered.
-  if (prerender::PrerenderHelper::IsPrerendering(render_frame()))
+  // Don't index/capture pages that are being no-state prefetched.
+  if (prerender::NoStatePrefetchHelper::IsPrefetching(render_frame()))
     return;
 
     // Don't capture contents unless there is either a translate agent or a

chrome/renderer/url_loader_throttle_provider_impl.cc

@@ -20,7 +20,7 @@
 #include "chrome/renderer/lite_video/lite_video_url_loader_throttle.h"
 #include "chrome/renderer/subresource_redirect/subresource_redirect_params.h"
 #include "chrome/renderer/subresource_redirect/subresource_redirect_url_loader_throttle.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/safe_browsing/content/renderer/renderer_url_loader_throttle.h"
 #include "components/safe_browsing/core/features.h"
 #include "content/public/common/content_features.h"
@@ -153,7 +153,7 @@ URLLoaderThrottleProviderImpl::CreateThrottles(
   if (type_ == content::URLLoaderThrottleProviderType::kFrame &&
       !is_frame_resource) {
     auto throttle =
-        prerender::PrerenderHelper::MaybeCreateThrottle(render_frame_id);
+        prerender::NoStatePrefetchHelper::MaybeCreateThrottle(render_frame_id);
     if (throttle)
       throttles.push_back(std::move(throttle));
   }

components/no_state_prefetch/renderer/BUILD.gn

@@ -6,8 +6,8 @@ static_library("renderer") {
   sources = [
     "no_state_prefetch_client.cc",
     "no_state_prefetch_client.h",
-    "prerender_helper.cc",
-    "prerender_helper.h",
+    "no_state_prefetch_helper.cc",
+    "no_state_prefetch_helper.h",
     "prerender_observer.h",
     "prerender_observer_list.cc",
     "prerender_observer_list.h",

components/no_state_prefetch/renderer/no_state_prefetch_client.cc

@@ -5,7 +5,7 @@
 #include "components/no_state_prefetch/renderer/no_state_prefetch_client.h"
 
 #include "base/logging.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/blink/public/web/web_view.h"
@@ -22,7 +22,8 @@ NoStatePrefetchClient::NoStatePrefetchClient(content::RenderView* render_view)
 NoStatePrefetchClient::~NoStatePrefetchClient() = default;
 
 bool NoStatePrefetchClient::IsPrefetchOnly() {
-  return PrerenderHelper::IsPrerendering(render_view()->GetMainRenderFrame());
+  return NoStatePrefetchHelper::IsPrefetching(
+      render_view()->GetMainRenderFrame());
 }
 
 void NoStatePrefetchClient::OnDestruct() {

components/no_state_prefetch/renderer/prerender_helper.cc → components/no_state_prefetch/renderer/no_state_prefetch_helper.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
@@ -17,26 +17,26 @@
 
 namespace prerender {
 
-PrerenderHelper::PrerenderHelper(content::RenderFrame* render_frame,
+NoStatePrefetchHelper::NoStatePrefetchHelper(
+    content::RenderFrame* render_frame,
     const std::string& histogram_prefix)
     : content::RenderFrameObserver(render_frame),
-      content::RenderFrameObserverTracker<PrerenderHelper>(render_frame),
+      content::RenderFrameObserverTracker<NoStatePrefetchHelper>(render_frame),
       histogram_prefix_(histogram_prefix),
-      start_time_(base::TimeTicks::Now()) {
-}
+      start_time_(base::TimeTicks::Now()) {}
 
-PrerenderHelper::~PrerenderHelper() = default;
+NoStatePrefetchHelper::~NoStatePrefetchHelper() = default;
 
 // static
-std::unique_ptr<blink::URLLoaderThrottle> PrerenderHelper::MaybeCreateThrottle(
-    int render_frame_id) {
+std::unique_ptr<blink::URLLoaderThrottle>
+NoStatePrefetchHelper::MaybeCreateThrottle(int render_frame_id) {
   content::RenderFrame* render_frame =
       content::RenderFrame::FromRoutingID(render_frame_id);
-  auto* prerender_helper =
-      render_frame ? PrerenderHelper::Get(
+  auto* helper = render_frame
+                     ? NoStatePrefetchHelper::Get(
                            render_frame->GetRenderView()->GetMainRenderFrame())
                      : nullptr;
-  if (!prerender_helper)
+  if (!helper)
     return nullptr;
 
   mojo::PendingRemote<mojom::PrerenderCanceler> canceler;
@@ -44,38 +44,39 @@ std::unique_ptr<blink::URLLoaderThrottle> PrerenderHelper::MaybeCreateThrottle(
       canceler.InitWithNewPipeAndPassReceiver());
 
   auto throttle = std::make_unique<PrerenderURLLoaderThrottle>(
-      prerender_helper->histogram_prefix(), std::move(canceler));
-  prerender_helper->AddThrottle(*throttle);
+      helper->histogram_prefix(), std::move(canceler));
+  helper->AddThrottle(*throttle);
   return throttle;
 }
 
 // static.
-bool PrerenderHelper::IsPrerendering(const content::RenderFrame* render_frame) {
-  return PrerenderHelper::Get(render_frame) != nullptr;
+bool NoStatePrefetchHelper::IsPrefetching(
+    const content::RenderFrame* render_frame) {
+  return NoStatePrefetchHelper::Get(render_frame) != nullptr;
 }
 
-void PrerenderHelper::DidFinishDocumentLoad() {
+void NoStatePrefetchHelper::DidFinishDocumentLoad() {
   parsed_time_ = base::TimeTicks::Now();
   prefetch_finished_ = true;
   if (prefetch_count_ == 0)
     SendPrefetchFinished();
 }
 
-void PrerenderHelper::OnDestruct() {
+void NoStatePrefetchHelper::OnDestruct() {
   delete this;
 }
 
-void PrerenderHelper::AddThrottle(PrerenderURLLoaderThrottle& throttle) {
+void NoStatePrefetchHelper::AddThrottle(PrerenderURLLoaderThrottle& throttle) {
   // Keep track of how many pending throttles we have, as we want to defer
   // sending the "prefetch finished" signal until they are destroyed. This is
   // important since that signal tells the browser that it can tear down this
   // renderer which could interrupt subresource prefetching.
   prefetch_count_++;
   throttle.set_destruction_closure(base::BindOnce(
-      &PrerenderHelper::OnThrottleDestroyed, weak_factory_.GetWeakPtr()));
+      &NoStatePrefetchHelper::OnThrottleDestroyed, weak_factory_.GetWeakPtr()));
 }
 
-void PrerenderHelper::OnThrottleDestroyed() {
+void NoStatePrefetchHelper::OnThrottleDestroyed() {
   if (--prefetch_count_ == 0 && prefetch_finished_) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Prerender.NoStatePrefetchRendererLifetimeExtension",
@@ -84,7 +85,7 @@ void PrerenderHelper::OnThrottleDestroyed() {
   }
 }
 
-void PrerenderHelper::SendPrefetchFinished() {
+void NoStatePrefetchHelper::SendPrefetchFinished() {
   DCHECK(prefetch_count_ == 0 && prefetch_finished_);
   UMA_HISTOGRAM_MEDIUM_TIMES("Prerender.NoStatePrefetchRendererParseTime",
                              parsed_time_ - start_time_);

components/no_state_prefetch/renderer/prerender_helper.h → components/no_state_prefetch/renderer/no_state_prefetch_helper.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_NO_STATE_PREFETCH_RENDERER_PRERENDER_HELPER_H_
-#define COMPONENTS_NO_STATE_PREFETCH_RENDERER_PRERENDER_HELPER_H_
+#ifndef COMPONENTS_NO_STATE_PREFETCH_RENDERER_NO_STATE_PREFETCH_HELPER_H_
+#define COMPONENTS_NO_STATE_PREFETCH_RENDERER_NO_STATE_PREFETCH_HELPER_H_
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ -19,24 +19,24 @@ class URLLoaderThrottle;
 namespace prerender {
 class PrerenderURLLoaderThrottle;
 
-// Helper class to track whether its RenderFrame is currently being prerendered.
-// Created when prerendering starts and deleted as soon as it stops.
-class PrerenderHelper
+// Helper class to track whether its RenderFrame is currently being no-state
+// prefetched. Created when prefetching starts and deleted as soon as it stops.
+class NoStatePrefetchHelper
     : public content::RenderFrameObserver,
-      public content::RenderFrameObserverTracker<PrerenderHelper> {
+      public content::RenderFrameObserverTracker<NoStatePrefetchHelper> {
  public:
-  PrerenderHelper(content::RenderFrame* render_frame,
+  NoStatePrefetchHelper(content::RenderFrame* render_frame,
                         const std::string& histogram_prefix);
 
-  ~PrerenderHelper() override;
+  ~NoStatePrefetchHelper() override;
 
   // Configures and returns a new PrerenderURLLoaderThrottle instance if the
-  // indicated frame has an associated PrerenderHelper.
+  // indicated frame has an associated NoStatePrefetchHelper.
   static std::unique_ptr<blink::URLLoaderThrottle> MaybeCreateThrottle(
       int render_frame_id);
 
-  // Returns true if |render_frame| is currently prerendering.
-  static bool IsPrerendering(const content::RenderFrame* render_frame);
+  // Returns true if |render_frame| is currently prefetching.
+  static bool IsPrefetching(const content::RenderFrame* render_frame);
 
   std::string histogram_prefix() const { return histogram_prefix_; }
 
@@ -56,11 +56,11 @@ class PrerenderHelper
   base::TimeTicks start_time_;
   base::TimeTicks parsed_time_;
 
-  base::WeakPtrFactory<PrerenderHelper> weak_factory_{this};
+  base::WeakPtrFactory<NoStatePrefetchHelper> weak_factory_{this};
 
-  DISALLOW_COPY_AND_ASSIGN(PrerenderHelper);
+  DISALLOW_COPY_AND_ASSIGN(NoStatePrefetchHelper);
 };
 
 }  // namespace prerender
 
-#endif  // COMPONENTS_NO_STATE_PREFETCH_RENDERER_PRERENDER_HELPER_H_
+#endif  // COMPONENTS_NO_STATE_PREFETCH_RENDERER_NO_STATE_PREFETCH_HELPER_H_

components/no_state_prefetch/renderer/prerender_render_frame_observer.cc

@@ -4,7 +4,7 @@
 
 #include "components/no_state_prefetch/renderer/prerender_render_frame_observer.h"
 
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/no_state_prefetch/renderer/prerender_observer_list.h"
 #include "content/public/renderer/render_frame.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
@@ -34,15 +34,14 @@ void PrerenderRenderFrameObserver::OnDestruct() {
 
 void PrerenderRenderFrameObserver::SetIsPrerendering(
     const std::string& histogram_prefix) {
-  // 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.
-  auto* prerender_helper = prerender::PrerenderHelper::Get(render_frame());
-  if (!prerender_helper) {
-    // The PrerenderHelper will destroy itself either after recording
+  // If the NoStatePrefetchHelper 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::NoStatePrefetchHelper::Get(render_frame())) {
+    // The NoStatePrefetchHelper will destroy itself either after recording
     // histograms or on destruction of the RenderView.
-    prerender_helper =
-        new prerender::PrerenderHelper(render_frame(), histogram_prefix);
+    new prerender::NoStatePrefetchHelper(render_frame(), histogram_prefix);
   }
 
   prerender::PrerenderObserverList::SetIsPrerenderingForFrame(

components/no_state_prefetch/renderer/prerender_utils.cc

@@ -4,7 +4,7 @@
 
 #include "components/no_state_prefetch/renderer/prerender_utils.h"
 
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "content/public/common/page_visibility_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
@@ -49,11 +49,11 @@ bool DeferMediaLoad(content::RenderFrame* render_frame,
   // and has never played any media before.  We want to allow future loads even
   // when hidden to allow playlist-like functionality.
   //
-  // NOTE: This is also used to defer media loading for prerender.
+  // NOTE: This is also used to defer media loading for NoStatePrefetch.
   if ((render_frame->GetRenderView()->GetWebView()->GetVisibilityState() !=
            content::PageVisibilityState::kVisible &&
        !has_played_media_before) ||
-      prerender::PrerenderHelper::IsPrerendering(render_frame)) {
+      prerender::NoStatePrefetchHelper::IsPrefetching(render_frame)) {
     new MediaLoadDeferrer(render_frame->GetRenderView(), std::move(closure));
     return true;
   }

weblayer/renderer/content_renderer_client_impl.cc

@@ -14,7 +14,7 @@
 #include "components/js_injection/renderer/js_communication.h"
 #include "components/no_state_prefetch/common/prerender_url_loader_throttle.h"
 #include "components/no_state_prefetch/renderer/no_state_prefetch_client.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/no_state_prefetch/renderer/prerender_render_frame_observer.h"
 #include "components/no_state_prefetch/renderer/prerender_utils.h"
 #include "components/page_load_metrics/renderer/metrics_render_frame_observer.h"
@@ -128,13 +128,15 @@ void ContentRendererClientImpl::RenderFrameCreated(
   new js_injection::JsCommunication(render_frame);
 
   if (!render_frame->IsMainFrame()) {
-    auto* prerender_helper = prerender::PrerenderHelper::Get(
+    auto* main_frame_no_state_prefetch_helper =
+        prerender::NoStatePrefetchHelper::Get(
             render_frame->GetRenderView()->GetMainRenderFrame());
-    if (prerender_helper) {
+    if (main_frame_no_state_prefetch_helper) {
       // Avoid any race conditions from having the browser tell subframes that
-      // they're prerendering.
-      new prerender::PrerenderHelper(render_frame,
-                                     prerender_helper->histogram_prefix());
+      // they're no-state prefetching.
+      new prerender::NoStatePrefetchHelper(
+          render_frame,
+          main_frame_no_state_prefetch_helper->histogram_prefix());
     }
   }
 }
@@ -198,7 +200,7 @@ void ContentRendererClientImpl::
 
 bool ContentRendererClientImpl::IsPrefetchOnly(
     content::RenderFrame* render_frame) {
-  return prerender::PrerenderHelper::IsPrerendering(render_frame);
+  return prerender::NoStatePrefetchHelper::IsPrefetching(render_frame);
 }
 
 bool ContentRendererClientImpl::DeferMediaLoad(

weblayer/renderer/url_loader_throttle_provider.cc

@@ -7,7 +7,7 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/safe_browsing/content/renderer/renderer_url_loader_throttle.h"
 #include "content/public/renderer/render_thread.h"
 #include "third_party/blink/public/common/loader/resource_type_util.h"
@@ -69,7 +69,7 @@ URLLoaderThrottleProvider::CreateThrottles(
   if (type_ == content::URLLoaderThrottleProviderType::kFrame &&
       !is_frame_resource) {
     auto throttle =
-        prerender::PrerenderHelper::MaybeCreateThrottle(render_frame_id);
+        prerender::NoStatePrefetchHelper::MaybeCreateThrottle(render_frame_id);
     if (throttle)
       throttles.push_back(std::move(throttle));
   }

weblayer/renderer/weblayer_render_frame_observer.cc

@@ -8,7 +8,7 @@
 
 #include "base/metrics/histogram_macros.h"
 #include "base/time/time.h"
-#include "components/no_state_prefetch/renderer/prerender_helper.h"
+#include "components/no_state_prefetch/renderer/no_state_prefetch_helper.h"
 #include "components/translate/content/renderer/translate_agent.h"
 #include "components/translate/core/common/translate_util.h"
 #include "third_party/blink/public/web/web_document_loader.h"
@@ -115,8 +115,8 @@ void WebLayerRenderFrameObserver::CapturePageText(
   if (document_loader && document_loader->HasUnreachableURL())
     return;
 
-  // Don't index/capture pages that are being prerendered.
-  if (prerender::PrerenderHelper::IsPrerendering(render_frame()))
+  // Don't index/capture pages that are being no-state prefetched.
+  if (prerender::NoStatePrefetchHelper::IsPrefetching(render_frame()))
     return;
 
     // Don't capture contents unless there is either a translate agent or a