Change Background freezing to freeze the execution context.

The execution context state was never adjusted when a page was frozen.

ContextStateChangedListeners fire when the state of execution context
changes.
This adds a number of things that are desirable for background tab
freezing:
- Workers being frozen as well
- Mojo channels are appropriately dropped for IPCs while in the frozen
state

Add PauseExecutionContextOnBackgroundFreeze feature to control this and
enable feature experimentally for now. Added a content feature kill
switch for this as well.

The desire is that bfcache, iframe freezing, sync event calls
(window.print()) and background tab freezing all will share the
same code paths for task scheduling adjustment.

Intent to Implement:
https://groups.google.com/a/chromium.org/d/msg/blink-dev/KwDF6Eavfek/Qb48J5ceAwAJ

BUG=957589

Change-Id: Ic5b94ed971f4fe0883c39039534efd64ffd290f1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1588158Reviewed-by: Nasko Oskov <nasko@chromium.org>
Reviewed-by: Shubhie Panicker <panicker@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#663151}

content/child/runtime_features.cc

@@ -518,6 +518,11 @@ void SetIndividualRuntimeFeatures(
     WebRuntimeFeatures::EnableFeatureFromString(
         "AudioWorkletRealtimeThread", true);
   }
+
+  if (!base::FeatureList::IsEnabled(
+          features::kPauseExecutionContextOnBackgroundFreeze)) {
+    WebRuntimeFeatures::EnablePauseExecutionContextOnBackgroundFreeze(false);
+  }
 }
 
 }  // namespace

content/public/common/content_features.cc

@@ -315,6 +315,11 @@ const base::Feature kPassiveEventListenersDueToFling{
 const base::Feature kPaymentRequestHasEnrolledInstrument = {
     "PaymentRequestHasEnrolledInstrument", base::FEATURE_ENABLED_BY_DEFAULT};
 
+// Whether ExecutionContext is paused (and workers) on background freeze.
+const base::Feature kPauseExecutionContextOnBackgroundFreeze = {
+    "PauseExecutionContextOnBackgroundFreeze",
+    base::FEATURE_ENABLED_BY_DEFAULT};
+
 // Whether PDF files should be rendered in diffent processes based on origin.
 const base::Feature kPdfIsolation = {"PdfIsolation",
                                      base::FEATURE_ENABLED_BY_DEFAULT};

content/public/common/content_features.h

@@ -77,6 +77,8 @@ CONTENT_EXPORT extern const base::Feature kOverscrollHistoryNavigation;
 CONTENT_EXPORT extern const base::Feature kPassiveDocumentEventListeners;
 CONTENT_EXPORT extern const base::Feature kPassiveDocumentWheelEventListeners;
 CONTENT_EXPORT extern const base::Feature kPassiveEventListenersDueToFling;
+CONTENT_EXPORT extern const base::Feature
+    kPauseExecutionContextOnBackgroundFreeze;
 CONTENT_EXPORT extern const base::Feature kPaymentRequestHasEnrolledInstrument;
 CONTENT_EXPORT extern const base::Feature kPdfIsolation;
 CONTENT_EXPORT extern const base::Feature kPeriodicBackgroundSync;

third_party/blink/public/platform/web_runtime_features.h

@@ -245,6 +245,8 @@ class WebRuntimeFeatures {
   BLINK_PLATFORM_EXPORT static void EnableStaleWhileRevalidate(bool);
   BLINK_PLATFORM_EXPORT static void EnableSmsReceiver(bool);
   BLINK_PLATFORM_EXPORT static void EnableDisplayLocking(bool);
+  BLINK_PLATFORM_EXPORT static void
+  EnablePauseExecutionContextOnBackgroundFreeze(bool);
 
  private:
   WebRuntimeFeatures();

third_party/blink/renderer/core/page/page.cc

@@ -503,6 +503,36 @@ void Page::SetLifecycleState(PageLifecycleState state) {
     return;
   DCHECK_NE(state, PageLifecycleState::kUnknown);
 
+  // When background tab freezing was first shipped it didn't pause
+  // the execution context but froze the frame scheduler. This feature
+  // flag attempts to bring the two mechanisms to use the same path for
+  // all pausing and freezing.
+  // This allows for mojo channels, workers to also be frozen because
+  // they listen for the page execution context being paused/frozen.
+  if (RuntimeEnabledFeatures::
+          PauseExecutionContextOnBackgroundFreezeEnabled()) {
+    base::Optional<mojom::FrameLifecycleState> next_state;
+    if (state == PageLifecycleState::kFrozen) {
+      next_state = mojom::FrameLifecycleState::kFrozen;
+    } else if (page_lifecycle_state_ == PageLifecycleState::kFrozen) {
+      // TODO(fmeawad): Only resume the page that just became visible, blocked
+      // on task queues per frame.
+      DCHECK(state == PageLifecycleState::kActive ||
+             state == PageLifecycleState::kHiddenBackgrounded ||
+             state == PageLifecycleState::kHiddenForegrounded);
+      next_state = mojom::FrameLifecycleState::kRunning;
+    }
+
+    if (next_state) {
+      for (Frame* frame = main_frame_.Get(); frame;
+           frame = frame->Tree().TraverseNext()) {
+        if (auto* local_frame = DynamicTo<LocalFrame>(frame))
+          local_frame->SetLifecycleState(next_state.value());
+      }
+    }
+  } else {
+    // The following code will dispatch the freeze/resume events,
+    // freeze the frame scheduler but but not pause the execution context.
     if (state == PageLifecycleState::kFrozen) {
       for (Frame* frame = main_frame_.Get(); frame;
            frame = frame->Tree().TraverseNext()) {
@@ -519,6 +549,7 @@ void Page::SetLifecycleState(PageLifecycleState state) {
         frame->DidResume();
       }
     }
+  }
   page_lifecycle_state_ = state;
 }
 

third_party/blink/renderer/platform/exported/web_runtime_features.cc

@@ -693,4 +693,10 @@ void WebRuntimeFeatures::EnableDisplayLocking(bool enable) {
   RuntimeEnabledFeatures::SetDisplayLockingEnabled(enable);
 }
 
+void WebRuntimeFeatures::EnablePauseExecutionContextOnBackgroundFreeze(
+    bool enable) {
+  RuntimeEnabledFeatures::SetPauseExecutionContextOnBackgroundFreezeEnabled(
+      enable);
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -1073,6 +1073,10 @@
     {
       name: "PassPaintVisualRectToCompositor",
     },
+    {
+      name: "PauseExecutionContextOnBackgroundFreeze",
+      status: "experimental",
+    },
     {
       name: "PaymentApp",
       status: "experimental",