[bfcache] Add bfcache defer enum to differentiate from normal deferring

This CL makes normal load deferring (i.e. pausing, frozen background etc)
and bfcache load deferring different.
This is to avoid bfcache specific calls all the time, such as eviction.

Also this allows to set memory limit / time limit for network requests
only for bfcache, without changing normal deferring behavior.

Bug: 1137682
Change-Id: I6b9f082ad0c4ebb959730106381673e1aae8bb61
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2549023
Commit-Queue: Yuzu Saijo <yuzus@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#830525}

content/renderer/loader/navigation_body_loader_unittest.cc

@@ -226,6 +226,18 @@ TEST_F(NavigationBodyLoaderTest, StartDeferred) {
   EXPECT_EQ("hello", TakeDataReceived());
 }
 
+TEST_F(NavigationBodyLoaderTest, StartDeferredWithBackForwardCache) {
+  CreateBodyLoader();
+  loader_->SetDefersLoading(
+      blink::WebURLLoader::DeferType::kDeferredWithBackForwardCache);
+  StartLoading();
+  Write("hello");
+  ExpectDataReceived();
+  loader_->SetDefersLoading(blink::WebURLLoader::DeferType::kNotDeferred);
+  Wait();
+  EXPECT_EQ("hello", TakeDataReceived());
+}
+
 TEST_F(NavigationBodyLoaderTest, OnCompleteThenClose) {
   CreateBodyLoader();
   StartLoading();

content/renderer/loader/url_loader_client_impl.cc

@@ -374,6 +374,15 @@ void URLLoaderClientImpl::OnReceiveRedirect(
     const net::RedirectInfo& redirect_info,
     network::mojom::URLResponseHeadPtr response_head) {
   DCHECK(!has_received_response_head_);
+  if (deferred_state_ ==
+      blink::WebURLLoader::DeferType::kDeferredWithBackForwardCache) {
+    // TODO(yuzus): Evict here.
+    // Close the connections and disptach and OnComplete message.
+    url_loader_.reset();
+    url_loader_client_receiver_.reset();
+    OnComplete(network::URLLoaderCompletionStatus(net::ERR_ABORTED));
+    return;
+  }
   if (!bypass_redirect_checks_ &&
       !IsRedirectSafe(last_loaded_url_, redirect_info.new_url)) {
     OnComplete(network::URLLoaderCompletionStatus(net::ERR_UNSAFE_REDIRECT));

third_party/blink/public/platform/web_url_loader.h

@@ -95,9 +95,16 @@ class WebURLLoader {
       WebURLLoaderClient*) = 0;
 
   // |kDeferred| is when an asynchronous load is suspended.
+  // |kDeferredWithBackForwardCache| is when an asynchronous load is suspended
+  // with BackForwardCache, and BackForwardCache entry can be evicted when
+  // redirects etc. happen.
   // |kNotDeferred| is when an asynchronous load is resumed.
   // SetDefersLoading can be called with any value at any point.
-  enum class DeferType { kDeferred, kNotDeferred };
+  enum class DeferType {
+    kDeferred,
+    kDeferredWithBackForwardCache,
+    kNotDeferred
+  };
   // Suspends/resumes an asynchronous load.
   virtual void SetDefersLoading(DeferType) = 0;
 

third_party/blink/renderer/core/execution_context/execution_context.cc

@@ -234,7 +234,9 @@ bool ExecutionContext::IsContextPaused() const {
 }
 
 WebURLLoader::DeferType ExecutionContext::DeferType() const {
-  if (lifecycle_state_ == mojom::blink::FrameLifecycleState::kPaused) {
+  if (lifecycle_state_ == mojom::blink::FrameLifecycleState::kFrozen) {
+    return WebURLLoader::DeferType::kDeferredWithBackForwardCache;
+  } else if (lifecycle_state_ == mojom::blink::FrameLifecycleState::kPaused) {
     return WebURLLoader::DeferType::kDeferred;
   }
   return WebURLLoader::DeferType::kNotDeferred;

third_party/blink/renderer/core/frame/local_frame.cc

@@ -2377,6 +2377,8 @@ bool LocalFrame::IsLoadDeferred() {
 }
 
 WebURLLoader::DeferType LocalFrame::GetLoadDeferType() {
+  if (GetPage()->GetPageScheduler()->IsInBackForwardCache())
+    return WebURLLoader::DeferType::kDeferredWithBackForwardCache;
   if (paused_ || frozen_)
     return WebURLLoader::DeferType::kDeferred;
   return WebURLLoader::DeferType::kNotDeferred;
@@ -2396,7 +2398,10 @@ void LocalFrame::DidFreeze() {
         performance_manager::mojom::LifecycleState::kFrozen);
   }
 
-  WebURLLoader::DeferType defer = WebURLLoader::DeferType::kDeferred;
+  WebURLLoader::DeferType defer =
+      GetPage()->GetPageScheduler()->IsInBackForwardCache()
+          ? WebURLLoader::DeferType::kDeferredWithBackForwardCache
+          : WebURLLoader::DeferType::kDeferred;
   GetDocument()->Fetcher()->SetDefersLoading(defer);
   Loader().SetDefersLoading(defer);
 }

third_party/blink/renderer/platform/loader/fetch/resource_loader_defer_loading_test.cc

@@ -258,6 +258,30 @@ TEST_F(ResourceLoaderDefersLoadingTest, ChangeDefersToTrue) {
   DCHECK_EQ(web_url_loader_defers_, WebURLLoader::DeferType::kDeferred);
 }
 
+TEST_F(ResourceLoaderDefersLoadingTest, ChangeDefersToBfcacheDefer) {
+  auto* fetcher = CreateFetcher();
+
+  ResourceRequest request;
+  request.SetUrl(test_url_);
+  request.SetRequestContext(mojom::blink::RequestContextType::FETCH);
+  FetchParameters fetch_parameters =
+      FetchParameters::CreateForTest(std::move(request));
+
+  Resource* resource = RawResource::Fetch(fetch_parameters, fetcher, nullptr);
+  DCHECK_EQ(web_url_loader_defers_, WebURLLoader::DeferType::kDeferred);
+
+  ResourceLoader* loader = resource->Loader();
+  loader->SetDefersLoading(
+      WebURLLoader::DeferType::kDeferredWithBackForwardCache);
+  DCHECK_EQ(web_url_loader_defers_, WebURLLoader::DeferType::kDeferred);
+
+  std::move(code_cache_response_callback_).Run(base::Time(), {});
+  // Since it was requested to be deferred, it should be reset to the
+  // correct value.
+  DCHECK_EQ(web_url_loader_defers_,
+            WebURLLoader::DeferType::kDeferredWithBackForwardCache);
+}
+
 TEST_F(ResourceLoaderDefersLoadingTest, ChangeDefersMultipleTimes) {
   auto* fetcher = CreateFetcher();
 

third_party/blink/renderer/platform/loader/static_data_navigation_body_loader_test.cc

@@ -107,6 +107,18 @@ TEST_F(StaticDataNavigationBodyLoaderTest,
   EXPECT_EQ("world", TakeDataReceived());
 }
 
+TEST_F(StaticDataNavigationBodyLoaderTest,
+       SetDefersLoadingWithBfcacheAndWriteFromDataReceived) {
+  loader_->StartLoadingBody(this, false);
+  expecting_data_received_ = true;
+  set_defers_loading_ = WebURLLoader::DeferType::kDeferredWithBackForwardCache;
+  buffer_to_write_ = "world";
+  Write("hello");
+  EXPECT_EQ("hello", TakeDataReceived());
+  loader_->SetDefersLoading(WebURLLoader::DeferType::kNotDeferred);
+  EXPECT_EQ("world", TakeDataReceived());
+}
+
 TEST_F(StaticDataNavigationBodyLoaderTest, DestroyFromDataReceived) {
   loader_->StartLoadingBody(this, false);
   expecting_data_received_ = true;
@@ -125,6 +137,17 @@ TEST_F(StaticDataNavigationBodyLoaderTest, SetDefersLoadingFromDataReceived) {
   EXPECT_EQ("", TakeDataReceived());
 }
 
+TEST_F(StaticDataNavigationBodyLoaderTest,
+       SetDefersLoadingWithBfcacheFromDataReceived) {
+  loader_->StartLoadingBody(this, false);
+  expecting_data_received_ = true;
+  set_defers_loading_ = WebURLLoader::DeferType::kDeferredWithBackForwardCache;
+  Write("hello");
+  EXPECT_EQ("hello", TakeDataReceived());
+  Write("world");
+  EXPECT_EQ("", TakeDataReceived());
+}
+
 TEST_F(StaticDataNavigationBodyLoaderTest, WriteThenStart) {
   Write("hello");
   expecting_data_received_ = true;
@@ -150,6 +173,20 @@ TEST_F(StaticDataNavigationBodyLoaderTest,
   EXPECT_TRUE(did_finish_);
 }
 
+TEST_F(StaticDataNavigationBodyLoaderTest,
+       SetDefersLoadingWithBfcacheFromFinishedDataReceived) {
+  Write("hello");
+  loader_->Finish();
+  expecting_data_received_ = true;
+  set_defers_loading_ = WebURLLoader::DeferType::kDeferredWithBackForwardCache;
+  loader_->StartLoadingBody(this, false);
+  EXPECT_EQ("hello", TakeDataReceived());
+  expecting_finished_ = true;
+  loader_->SetDefersLoading(WebURLLoader::DeferType::kNotDeferred);
+  EXPECT_EQ("", TakeDataReceived());
+  EXPECT_TRUE(did_finish_);
+}
+
 TEST_F(StaticDataNavigationBodyLoaderTest, StartDeferred) {
   loader_->SetDefersLoading(WebURLLoader::DeferType::kDeferred);
   loader_->StartLoadingBody(this, false);
@@ -159,6 +196,16 @@ TEST_F(StaticDataNavigationBodyLoaderTest, StartDeferred) {
   EXPECT_EQ("hello", TakeDataReceived());
 }
 
+TEST_F(StaticDataNavigationBodyLoaderTest, StartDeferredWithBackForwardCache) {
+  loader_->SetDefersLoading(
+      WebURLLoader::DeferType::kDeferredWithBackForwardCache);
+  loader_->StartLoadingBody(this, false);
+  Write("hello");
+  expecting_data_received_ = true;
+  loader_->SetDefersLoading(WebURLLoader::DeferType::kNotDeferred);
+  EXPECT_EQ("hello", TakeDataReceived());
+}
+
 TEST_F(StaticDataNavigationBodyLoaderTest, DestroyFromFinished) {
   loader_->StartLoadingBody(this, false);
   expecting_finished_ = true;
@@ -175,4 +222,12 @@ TEST_F(StaticDataNavigationBodyLoaderTest, SetDefersLoadingFromFinished) {
   EXPECT_TRUE(did_finish_);
 }
 
+TEST_F(StaticDataNavigationBodyLoaderTest,
+       SetDefersLoadingWithBfcacheFromFinished) {
+  loader_->StartLoadingBody(this, false);
+  expecting_finished_ = true;
+  set_defers_loading_ = WebURLLoader::DeferType::kDeferredWithBackForwardCache;
+  loader_->Finish();
+  EXPECT_TRUE(did_finish_);
+}
 }  // namespace blink