diff --git a/content/browser/back_forward_cache_browsertest.cc b/content/browser/back_forward_cache_browsertest.cc index f8dd212d76c6ad..5c9336e0a756f2 100644 --- a/content/browser/back_forward_cache_browsertest.cc +++ b/content/browser/back_forward_cache_browsertest.cc @@ -8702,126 +8702,4 @@ IN_PROC_BROWSER_TEST_F(BackForwardCacheBrowserTestWithFileSystemAPISupported, FROM_HERE); } -class BackForwardCacheBrowserTestWithSupportedFeatures - : public BackForwardCacheBrowserTest { - protected: - void SetUpCommandLine(base::CommandLine* command_line) override { - EnableFeatureAndSetParams(features::kBackForwardCache, "supported_features", - "WebFileSystem,WebLocks"); - BackForwardCacheBrowserTest::SetUpCommandLine(command_line); - } -}; - -IN_PROC_BROWSER_TEST_F(BackForwardCacheBrowserTestWithSupportedFeatures, - CacheWithFileSystemAPI) { - ASSERT_TRUE(embedded_test_server()->Start()); - GURL url_a(embedded_test_server()->GetURL("/fileapi/request_test.html")); - GURL url_b(embedded_test_server()->GetURL("b.com", "/title1.html")); - - // 1) Navigate to the page A with WebFileSystem usage. - EXPECT_TRUE(NavigateToURL(shell(), url_a)); - RenderFrameHostImpl* rfh_a = current_frame_host(); - RenderFrameDeletedObserver deleted(rfh_a); - - // 2) Navigate away. - EXPECT_TRUE(NavigateToURL(shell(), url_b)); - EXPECT_FALSE(deleted.deleted()); - EXPECT_TRUE(rfh_a->IsInBackForwardCache()); - - // 3) Go back to the page A - web_contents()->GetController().GoBack(); - EXPECT_TRUE(WaitForLoadStop(shell()->web_contents())); - EXPECT_EQ(rfh_a, current_frame_host()); - ExpectOutcome(BackForwardCacheMetrics::HistoryNavigationOutcome::kRestored, - FROM_HERE); - - // 4) Use WebLock - EXPECT_TRUE(ExecJs(rfh_a, R"( - const never_resolved = new Promise(resolve => {}); - new Promise(continue_test => { - navigator.locks.request('test', async () => { - continue_test(); - await never_resolved; - }); - }) - )")); - - // 5) Navigate away again. - EXPECT_TRUE(NavigateToURL(shell(), url_b)); - EXPECT_FALSE(deleted.deleted()); - EXPECT_TRUE(rfh_a->IsInBackForwardCache()); - - // 6) Go back to the page A again. - web_contents()->GetController().GoBack(); - EXPECT_TRUE(WaitForLoadStop(shell()->web_contents())); - EXPECT_EQ(rfh_a, current_frame_host()); - ExpectOutcome(BackForwardCacheMetrics::HistoryNavigationOutcome::kRestored, - FROM_HERE); -} - -class BackForwardCacheBrowserTestWithNoSupportedFeatures - : public BackForwardCacheBrowserTest { - protected: - void SetUpCommandLine(base::CommandLine* command_line) override { - // Specify empty supported features explicitly. - EnableFeatureAndSetParams(features::kBackForwardCache, "supported_features", - ""); - BackForwardCacheBrowserTest::SetUpCommandLine(command_line); - } -}; - -IN_PROC_BROWSER_TEST_F(BackForwardCacheBrowserTestWithNoSupportedFeatures, - DontCacheWithFileSystemAPI) { - ASSERT_TRUE(embedded_test_server()->Start()); - GURL url_a(embedded_test_server()->GetURL("/fileapi/request_test.html")); - GURL url_b(embedded_test_server()->GetURL("b.com", "/title1.html")); - - // 1) Navigate to the page A with WebFileSystem usage. - EXPECT_TRUE(NavigateToURL(shell(), url_a)); - RenderFrameHostImpl* rfh_a1 = current_frame_host(); - RenderFrameDeletedObserver deleted_a1(rfh_a1); - - // 2) Navigate away. - EXPECT_TRUE(NavigateToURL(shell(), url_b)); - EXPECT_TRUE(deleted_a1.deleted()); - - // 3) Go back to the page A - web_contents()->GetController().GoBack(); - EXPECT_TRUE(WaitForLoadStop(shell()->web_contents())); - ExpectNotRestored( - {BackForwardCacheMetrics::NotRestoredReason::kBlocklistedFeatures}, - FROM_HERE); - ExpectBlocklistedFeature( - blink::scheduler::WebSchedulerTrackedFeature::kWebFileSystem, FROM_HERE); - - RenderFrameHostImpl* rfh_a2 = current_frame_host(); - RenderFrameDeletedObserver deleted_a2(rfh_a2); - - // 4) Use WebLock - EXPECT_TRUE(ExecJs(rfh_a2, R"( - const never_resolved = new Promise(resolve => {}); - new Promise(continue_test => { - navigator.locks.request('test', async () => { - continue_test(); - await never_resolved; - }); - }) - )")); - - // 5) Navigate away again. - EXPECT_TRUE(NavigateToURL(shell(), url_b)); - EXPECT_TRUE(deleted_a2.deleted()); - - // 6) Go back to the page A again. - web_contents()->GetController().GoBack(); - EXPECT_TRUE(WaitForLoadStop(shell()->web_contents())); - ExpectNotRestored( - {BackForwardCacheMetrics::NotRestoredReason::kBlocklistedFeatures}, - FROM_HERE); - ExpectBlocklistedFeatures( - {blink::scheduler::WebSchedulerTrackedFeature::kWebFileSystem, - blink::scheduler::WebSchedulerTrackedFeature::kWebLocks}, - FROM_HERE); -} - } // namespace content diff --git a/content/browser/renderer_host/back_forward_cache_can_store_document_result.cc b/content/browser/renderer_host/back_forward_cache_can_store_document_result.cc index 1dd29431492f56..6da52e8b1edf2c 100644 --- a/content/browser/renderer_host/back_forward_cache_can_store_document_result.cc +++ b/content/browser/renderer_host/back_forward_cache_can_store_document_result.cc @@ -18,7 +18,7 @@ std::string DescribeFeatures(uint64_t blocklisted_features) { for (size_t i = 0; i <= static_cast(WebSchedulerTrackedFeature::kMaxValue); ++i) { if (blocklisted_features & (1 << i)) { - features.push_back(blink::scheduler::FeatureToHumanReadableString( + features.push_back(blink::scheduler::FeatureToString( static_cast(i))); } } diff --git a/content/browser/renderer_host/back_forward_cache_impl.cc b/content/browser/renderer_host/back_forward_cache_impl.cc index 75bcf041f3db66..857dc33eeddc4f 100644 --- a/content/browser/renderer_host/back_forward_cache_impl.cc +++ b/content/browser/renderer_host/back_forward_cache_impl.cc @@ -96,31 +96,6 @@ bool IsFileSystemSupported() { return file_system_api_supported.Get(); } -uint64_t SupportedFeaturesBitmaskImpl() { - if (!DeviceHasEnoughMemoryForBackForwardCache()) - return 0; - - static constexpr base::FeatureParam supported_features( - &features::kBackForwardCache, "supported_features", ""); - std::vector tokens = - base::SplitString(supported_features.Get(), ",", base::TRIM_WHITESPACE, - base::SPLIT_WANT_NONEMPTY); - uint64_t mask = 0; - for (const std::string& token : tokens) { - auto feature = blink::scheduler::StringToFeature(token); - DCHECK(feature.has_value()) << "invalid feature string: " << token; - if (feature.has_value()) { - mask |= blink::scheduler::FeatureToBit(feature.value()); - } - } - return mask; -} - -uint64_t SupportedFeaturesBitmask() { - static uint64_t mask = SupportedFeaturesBitmaskImpl(); - return mask; -} - bool IgnoresOutstandingNetworkRequestForTesting() { if (!DeviceHasEnoughMemoryForBackForwardCache()) return false; @@ -212,8 +187,6 @@ uint64_t GetDisallowedFeatures(RenderFrameHostImpl* rfh, result &= blink::scheduler::StickyFeaturesBitmask(); } - result &= ~SupportedFeaturesBitmask(); - return result; } diff --git a/third_party/blink/common/BUILD.gn b/third_party/blink/common/BUILD.gn index 0984de800204e3..386f766e77621a 100644 --- a/third_party/blink/common/BUILD.gn +++ b/third_party/blink/common/BUILD.gn @@ -272,7 +272,6 @@ source_set("common_unittests_sources") { "origin_trials/trial_token_validator_unittest.cc", "page/content_to_visible_time_reporter_unittest.cc", "page_state/page_state_serialization_unittest.cc", - "scheduler/web_scheduler_tracked_feature_unittest.cc", "service_worker/service_worker_scope_match_unittest.cc", "test/run_all_unittests.cc", "tokens/multi_token_unittest.cc", diff --git a/third_party/blink/common/scheduler/web_scheduler_tracked_feature.cc b/third_party/blink/common/scheduler/web_scheduler_tracked_feature.cc index 09394b1dc1033d..5fb1fce3eb5b6a 100644 --- a/third_party/blink/common/scheduler/web_scheduler_tracked_feature.cc +++ b/third_party/blink/common/scheduler/web_scheduler_tracked_feature.cc @@ -4,175 +4,112 @@ #include "third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h" -#include - namespace blink { namespace scheduler { -namespace { - -struct FeatureNames { - std::string short_name; - std::string human_readable; -}; - -FeatureNames FeatureToNames(WebSchedulerTrackedFeature feature) { +const char* FeatureToString(WebSchedulerTrackedFeature feature) { switch (feature) { case WebSchedulerTrackedFeature::kWebSocket: - return {"WebSocket", "WebSocket"}; + return "WebSocket"; case WebSchedulerTrackedFeature::kWebRTC: - return {"WebRTC", "WebRTC"}; + return "WebRTC"; case WebSchedulerTrackedFeature::kMainResourceHasCacheControlNoCache: - return {"MainResourceHasCacheControlNoCache", - "main resource has Cache-Control: No-Cache"}; + return "main resource has Cache-Control: No-Cache"; case WebSchedulerTrackedFeature::kMainResourceHasCacheControlNoStore: - return {"MainResourceHasCacheControlNoStore", - "main resource has Cache-Control: No-Store"}; + return "main resource has Cache-Control: No-Store"; case WebSchedulerTrackedFeature::kSubresourceHasCacheControlNoCache: - return {"SubresourceHasCacheControlNoCache", - "subresource has Cache-Control: No-Cache"}; + return "subresource has Cache-Control: No-Cache"; case WebSchedulerTrackedFeature::kSubresourceHasCacheControlNoStore: - return {"SubresourceHasCacheControlNoStore", - "subresource has Cache-Control: No-Store"}; + return "subresource has Cache-Control: No-Store"; case WebSchedulerTrackedFeature::kPageShowEventListener: - return {"PageShowEventListener", "onpageshow() event listener"}; + return "onpageshow() event listener"; case WebSchedulerTrackedFeature::kPageHideEventListener: - return {"PageHideEventListener", "onpagehide() event listener"}; + return "onpagehide() event listener"; case WebSchedulerTrackedFeature::kBeforeUnloadEventListener: - return {"BeforeUnloadEventListener", "onbeforeunload() event listener"}; + return "onbeforeunload() event listener"; case WebSchedulerTrackedFeature::kUnloadEventListener: - return {"UnloadEventListener", "onunload() event listener"}; + return "onunload() event listener"; case WebSchedulerTrackedFeature::kFreezeEventListener: - return {"FreezeEventListener", "onfreeze() event listener"}; + return "onfreeze() event listener"; case WebSchedulerTrackedFeature::kResumeEventListener: - return {"ResumeEventListener", "onresume() event listener"}; + return "onresume() event listener"; case WebSchedulerTrackedFeature::kContainsPlugins: - return {"ContainsPlugins", "page contains plugins"}; + return "page contains plugins"; case WebSchedulerTrackedFeature::kDocumentLoaded: - return {"DocumentLoaded", "document loaded"}; + return "document loaded"; case WebSchedulerTrackedFeature::kDedicatedWorkerOrWorklet: - return {"DedicatedWorkerOrWorklet", - "Dedicated worker or worklet present"}; + return "Dedicated worker or worklet present"; case WebSchedulerTrackedFeature::kSharedWorker: - return {"SharedWorker", "Shared worker present"}; + return "Shared worker present"; case WebSchedulerTrackedFeature::kOutstandingNetworkRequestFetch: - return {"OutstandingNetworkRequestFetch", - "outstanding network request (fetch)"}; + return "outstanding network request (fetch)"; case WebSchedulerTrackedFeature::kOutstandingNetworkRequestXHR: - return {"OutstandingNetworkRequestXHR", - "outstanding network request (XHR)"}; + return "outstanding network request (XHR)"; case WebSchedulerTrackedFeature::kOutstandingNetworkRequestOthers: - return {"OutstandingNetworkRequestOthers", - "outstanding network request (others)"}; + return "outstanding network request (others)"; case WebSchedulerTrackedFeature::kOutstandingIndexedDBTransaction: - return {"OutstandingIndexedDBTransaction", - "outstanding IndexedDB transaction"}; + return "outstanding IndexedDB transaction"; case WebSchedulerTrackedFeature::kRequestedGeolocationPermission: - return {"RequestedGeolocationPermission", - "requested geolocation permission"}; + return "requested geolocation permission"; case WebSchedulerTrackedFeature::kRequestedNotificationsPermission: - return {"RequestedNotificationsPermission", - "requested notifications permission"}; + return "requested notifications permission"; case WebSchedulerTrackedFeature::kRequestedMIDIPermission: - return {"RequestedMIDIPermission", "requested midi permission"}; + return "requested midi permission"; case WebSchedulerTrackedFeature::kRequestedAudioCapturePermission: - return {"RequestedAudioCapturePermission", - "requested audio capture permission"}; + return "requested audio capture permission"; case WebSchedulerTrackedFeature::kRequestedVideoCapturePermission: - return {"RequestedVideoCapturePermission", - "requested video capture permission"}; + return "requested video capture permission"; case WebSchedulerTrackedFeature::kRequestedBackForwardCacheBlockedSensors: - return {"RequestedBackForwardCacheBlockedSensors", - "requested sensors permission"}; + return "requested sensors permission"; case WebSchedulerTrackedFeature::kRequestedBackgroundWorkPermission: - return {"RequestedBackgroundWorkPermission", - "requested background work permission"}; + return "requested background work permission"; case WebSchedulerTrackedFeature::kBroadcastChannel: - return {"BroadcastChannel", "requested broadcast channel permission"}; + return "requested broadcast channel permission"; case WebSchedulerTrackedFeature::kIndexedDBConnection: - return {"IndexedDBConnection", "IndexedDB connection present"}; + return "IndexedDB connection present"; case WebSchedulerTrackedFeature::kWebVR: - return {"WebVR", "WebVR"}; + return "WebVR"; case WebSchedulerTrackedFeature::kWebXR: - return {"WebXR", "WebXR"}; + return "WebXR"; case WebSchedulerTrackedFeature::kWebLocks: - return {"WebLocks", "WebLocks"}; + return "WebLocks"; case WebSchedulerTrackedFeature::kWebHID: - return {"WebHID", "WebHID"}; + return "WebHID"; case WebSchedulerTrackedFeature::kWakeLock: - return {"WakeLock", "WakeLock"}; + return "WakeLock"; case WebSchedulerTrackedFeature::kWebShare: - return {"WebShare", "WebShare"}; + return "WebShare"; case WebSchedulerTrackedFeature::kRequestedStorageAccessGrant: - return {"RequestedStorageAccessGrant", - "requested storage access permission"}; + return "requested storage access permission"; case WebSchedulerTrackedFeature::kWebNfc: - return {"WebNfc", "WebNfc"}; + return "WebNfc"; case WebSchedulerTrackedFeature::kWebFileSystem: - return {"WebFileSystem", "WebFileSystem"}; + return "WebFileSystem"; case WebSchedulerTrackedFeature::kAppBanner: - return {"AppBanner", "AppBanner"}; + return "AppBanner"; case WebSchedulerTrackedFeature::kPrinting: - return {"Printing", "Printing"}; + return "Printing"; case WebSchedulerTrackedFeature::kWebDatabase: - return {"WebDatabase", "WebDatabase"}; + return "WebDatabase"; case WebSchedulerTrackedFeature::kPictureInPicture: - return {"PictureInPicture", "PictureInPicture"}; + return "PictureInPicture"; case WebSchedulerTrackedFeature::kPortal: - return {"Portal", "Portal"}; + return "Portal"; case WebSchedulerTrackedFeature::kSpeechRecognizer: - return {"SpeechRecognizer", "SpeechRecognizer"}; + return "SpeechRecognizer"; case WebSchedulerTrackedFeature::kIdleManager: - return {"IdleManager", "IdleManager"}; + return "IdleManager"; case WebSchedulerTrackedFeature::kPaymentManager: - return {"PaymentManager", "PaymentManager"}; + return "PaymentManager"; case WebSchedulerTrackedFeature::kSpeechSynthesis: - return {"SpeechSynthesis", "SpeechSynthesis"}; + return "SpeechSynthesis"; case WebSchedulerTrackedFeature::kKeyboardLock: - return {"KeyboardLock", "KeyboardLock"}; + return "KeyboardLock"; case WebSchedulerTrackedFeature::kWebOTPService: - return {"WebOTPService", "SMSService"}; + return "SMSService"; case WebSchedulerTrackedFeature::kOutstandingNetworkRequestDirectSocket: - return {"OutstandingNetworkRequestDirectSocket", - "outstanding network request (direct socket)"}; - } - return {}; -} - -std::map MakeShortNameToFeature() { - std::map short_name_to_feature; - for (int i = 0; i <= static_cast(WebSchedulerTrackedFeature::kMaxValue); - i++) { - WebSchedulerTrackedFeature feature = - static_cast(i); - FeatureNames strs = FeatureToNames(feature); - if (strs.short_name.size()) - short_name_to_feature[strs.short_name] = feature; - } - return short_name_to_feature; -} - -const std::map& -ShortStringToFeatureMap() { - static const std::map - short_name_to_feature = MakeShortNameToFeature(); - return short_name_to_feature; -} - -} // namespace - -std::string FeatureToHumanReadableString(WebSchedulerTrackedFeature feature) { - return FeatureToNames(feature).human_readable; -} - -base::Optional StringToFeature( - const std::string& str) { - auto map = ShortStringToFeatureMap(); - auto it = map.find(str); - if (it == map.end()) { - return base::nullopt; + return "outstanding network request (direct socket)"; } - return it->second; } bool IsFeatureSticky(WebSchedulerTrackedFeature feature) { diff --git a/third_party/blink/common/scheduler/web_scheduler_tracked_feature_unittest.cc b/third_party/blink/common/scheduler/web_scheduler_tracked_feature_unittest.cc deleted file mode 100644 index 81b05ca5519913..00000000000000 --- a/third_party/blink/common/scheduler/web_scheduler_tracked_feature_unittest.cc +++ /dev/null @@ -1,21 +0,0 @@ -// 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 "third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h" - -#include "testing/gtest/include/gtest/gtest.h" - -namespace blink { -namespace scheduler { - -TEST(WebSchedulerTrackedFeatureTest, StringToFeature) { - ASSERT_EQ(WebSchedulerTrackedFeature::kWebFileSystem, - StringToFeature("WebFileSystem")); - ASSERT_EQ(WebSchedulerTrackedFeature::kDocumentLoaded, - StringToFeature("DocumentLoaded")); - ASSERT_EQ(base::nullopt, StringToFeature("FeatureThatNeverExists")); -} - -} // namespace scheduler -} // namespace blink diff --git a/third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h b/third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h index 1d3c4436afbbde..ac12649c235fdf 100644 --- a/third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h +++ b/third_party/blink/public/common/scheduler/web_scheduler_tracked_feature.h @@ -6,8 +6,7 @@ #define THIRD_PARTY_BLINK_PUBLIC_COMMON_SCHEDULER_WEB_SCHEDULER_TRACKED_FEATURE_H_ #include -#include -#include "base/optional.h" + #include "third_party/blink/public/common/common_export.h" namespace blink { @@ -107,12 +106,9 @@ static_assert(static_cast(WebSchedulerTrackedFeature::kMaxValue) < 64, "This enum is used in a bitmask, so the values should fit into a" "64-bit integer"); -BLINK_COMMON_EXPORT std::string FeatureToHumanReadableString( +BLINK_COMMON_EXPORT const char* FeatureToString( WebSchedulerTrackedFeature feature); -BLINK_COMMON_EXPORT base::Optional StringToFeature( - const std::string& str); - // Converts a WebSchedulerTrackedFeature to a bit for use in a bitmask. BLINK_COMMON_EXPORT constexpr uint64_t FeatureToBit( WebSchedulerTrackedFeature feature) { diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc b/third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc index 3679ba43243341..dfce9ed52666d5 100644 --- a/third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc +++ b/third_party/blink/renderer/platform/scheduler/main_thread/frame_scheduler_impl.cc @@ -668,7 +668,7 @@ void FrameSchedulerImpl::OnStartedUsingFeature( "renderer.scheduler", "ActiveSchedulerTrackedFeature", TRACE_ID_LOCAL(reinterpret_cast(this) ^ static_cast(feature)), - "feature", FeatureToHumanReadableString(feature)); + "feature", FeatureToString(feature)); } }