Revert "[PageLifecycle] Update the TabManager with the page freezing state"

This reverts commit 686a5f7b.

Reason for revert: suspected cause for https://ci.chromium.org/buildbot/chromium.webkit/WebKit%20Win10/ failures

external/wpt/websockets/constructor/014.html?wss ( Code Search )
external/wpt/websockets/keeping-connection-open/001.html?wss ( Code Search )
virtual/off-main-thread-websocket/external/wpt/websockets/constructor/014.html?wss ( Code Search )
virtual/off-main-thread-websocket/external/wpt/websockets/keeping-connection-open/001.html?wss ( Code Search )

Original change's description:
> [PageLifecycle] Update the TabManager with the page freezing state
> 
> In this CL, each frame updates its FrameResourceCoordinator with any
> updates the lifecycle state. If the main frame lifecycle state is
> updated, then the page inherit the new state.
> 
> The PageSignalGeneratorImpl then updates the state in TabLifecycleUnit
> which is used by the chrome:://discards UI.
> 
> The CL also disables freezing a Tab that is already frozen.
> 
> Bug: chromium:804976
> Cq-Include-Trybots: master.tryserver.chromium.linux:closure_compilation
> Change-Id: Iba82286a06af17ccb74a7f6fac18cdb7914c003a
> Reviewed-on: https://chromium-review.googlesource.com/942022
> Reviewed-by: Daniel Cheng <dcheng@chromium.org>
> Reviewed-by: François Doray <fdoray@chromium.org>
> Reviewed-by: Chris Hamilton <chrisha@chromium.org>
> Reviewed-by: Shubhie Panicker <panicker@chromium.org>
> Commit-Queue: Fadi Meawad <fmeawad@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#556084}

TBR=dcheng@chromium.org,chrisha@chromium.org,fdoray@chromium.org,fmeawad@chromium.org,altimin@chromium.org,panicker@chromium.org

Change-Id: Id1f8907c265e249d4bbe87cf514d66e6612fe18a
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: chromium:804976
Cq-Include-Trybots: master.tryserver.chromium.linux:closure_compilation
Reviewed-on: https://chromium-review.googlesource.com/1044573Reviewed-by: CJ DiMeglio <lethalantidote@chromium.org>
Commit-Queue: Fadi Meawad <fmeawad@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556144}

chrome/browser/resource_coordinator/discard_metrics_lifecycle_unit_observer.cc

@@ -18,20 +18,19 @@ DiscardMetricsLifecycleUnitObserver::~DiscardMetricsLifecycleUnitObserver() =
     default;
 
 void DiscardMetricsLifecycleUnitObserver::OnLifecycleUnitStateChanged(
-    LifecycleUnit* lifecycle_unit,
-    mojom::LifecycleState previous_state) {
-  if (lifecycle_unit->GetState() == mojom::LifecycleState::kDiscarded)
+    LifecycleUnit* lifecycle_unit) {
+  if (lifecycle_unit->GetState() == LifecycleUnit::State::DISCARDED)
     OnDiscard(lifecycle_unit);
-  else if (previous_state == mojom::LifecycleState::kDiscarded)
+  else
     OnReload();
 }
 
 void DiscardMetricsLifecycleUnitObserver::OnLifecycleUnitDestroyed(
     LifecycleUnit* lifecycle_unit) {
-  // If the browser is not shutting down and the tab is loaded after
+  // If the browser is not shutting down and the tab is in a LOADED state after
   // being discarded, record TabManager.Discarding.ReloadToCloseTime.
   if (g_browser_process && !g_browser_process->IsShuttingDown() &&
-      lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded &&
+      lifecycle_unit->GetState() == LifecycleUnit::State::LOADED &&
       !reload_time_.is_null()) {
     auto reload_to_close_time = NowTicks() - reload_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES(

chrome/browser/resource_coordinator/discard_metrics_lifecycle_unit_observer.h

@@ -19,9 +19,7 @@ class DiscardMetricsLifecycleUnitObserver : public LifecycleUnitObserver {
   ~DiscardMetricsLifecycleUnitObserver() override;
 
   // LifecycleUnitObserver:
-  void OnLifecycleUnitStateChanged(
-      LifecycleUnit* lifecycle_unit,
-      mojom::LifecycleState previous_state) override;
+  void OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit) override;
   void OnLifecycleUnitDestroyed(LifecycleUnit* lifecycle_unit) override;
 
  private:

chrome/browser/resource_coordinator/discard_metrics_lifecycle_unit_observer_unittest.cc

@@ -93,19 +93,19 @@ TEST_F(DiscardMetricsLifecycleUnitObserverTest, DiscardReloadCount) {
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 0);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 1);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleUnit::State::LOADED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 1);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 1);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 2);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 1);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleUnit::State::LOADED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 2);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 2);
 }
@@ -113,11 +113,11 @@ TEST_F(DiscardMetricsLifecycleUnitObserverTest, DiscardReloadCount) {
 TEST_F(DiscardMetricsLifecycleUnitObserverTest, DiscardToReloadTime) {
   histograms_.ExpectTotalCount(kDiscardToReloadTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   test_clock_.Advance(kShortDelay);
   histograms_.ExpectTotalCount(kDiscardToReloadTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleUnit::State::LOADED);
   histograms_.ExpectTimeBucketCount(kDiscardToReloadTimeHistogram, kShortDelay,
                                     1);
 }
@@ -128,11 +128,11 @@ TEST_F(DiscardMetricsLifecycleUnitObserverTest, InactiveToReloadTime) {
   const base::TimeTicks last_focused_time = NowTicks();
   lifecycle_unit_->SetLastFocusedTime(last_focused_time);
   test_clock_.Advance(kShortDelay);
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   test_clock_.Advance(kShortDelay);
   histograms_.ExpectTotalCount(kInactiveToReloadTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleUnit::State::LOADED);
   histograms_.ExpectTimeBucketCount(kInactiveToReloadTimeHistogram,
                                     2 * kShortDelay, 1);
 }
@@ -148,7 +148,7 @@ TEST_F(DiscardMetricsLifecycleUnitObserverTest,
        ReloadToCloseTimeDiscardedButNotReloaded) {
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   lifecycle_unit_.reset();
@@ -159,11 +159,11 @@ TEST_F(DiscardMetricsLifecycleUnitObserverTest, ReloadToCloseTime) {
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   test_clock_.Advance(kShortDelay * 1);
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleUnit::State::DISCARDED);
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   test_clock_.Advance(kShortDelay * 2);
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleUnit::State::LOADED);
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   test_clock_.Advance(kShortDelay * 4);

chrome/browser/resource_coordinator/lifecycle_unit.h

@@ -14,7 +14,6 @@
 #include "base/time/time.h"
 #include "chrome/browser/resource_coordinator/discard_reason.h"
 #include "content/public/browser/visibility.h"
-#include "services/resource_coordinator/public/mojom/lifecycle.mojom.h"
 
 namespace resource_coordinator {
 
@@ -27,6 +26,13 @@ class TabLifecycleUnitExternal;
 // use any system resource.
 class LifecycleUnit {
  public:
+  enum class State {
+    // The LifecycleUnit is using system resources.
+    LOADED,
+    // The LifecycleUnit is not using system resources.
+    DISCARDED,
+  };
+
   // Used to sort LifecycleUnit by importance. The most important LifecycleUnit
   // has the greatest SortKey.
   struct SortKey {
@@ -72,7 +78,7 @@ class LifecycleUnit {
   virtual SortKey GetSortKey() const = 0;
 
   // Returns the current state of this LifecycleUnit.
-  virtual mojom::LifecycleState GetState() const = 0;
+  virtual State GetState() const = 0;
 
   // Returns the current visibility of this LifecycleUnit.
   virtual content::Visibility GetVisibility() const = 0;
@@ -80,8 +86,8 @@ class LifecycleUnit {
   // Returns the last time that the visibility of the LifecycleUnit changed.
   virtual base::TimeTicks GetLastVisibilityChangeTime() const = 0;
 
-  // Request that the LifecycleUnit be frozen, return true if the request is
-  // successfully sent.
+  // Freezes this LifecycleUnit, i.e. prevents it from using the CPU. Returns
+  // true on success.
   virtual bool Freeze() = 0;
 
   // Returns the estimated number of kilobytes that would be freed if this

chrome/browser/resource_coordinator/lifecycle_unit_base.cc

@@ -18,7 +18,7 @@ int32_t LifecycleUnitBase::GetID() const {
   return id_;
 }
 
-mojom::LifecycleState LifecycleUnitBase::GetState() const {
+LifecycleUnit::State LifecycleUnitBase::GetState() const {
   return state_;
 }
 
@@ -34,13 +34,12 @@ void LifecycleUnitBase::RemoveObserver(LifecycleUnitObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void LifecycleUnitBase::SetState(mojom::LifecycleState state) {
+void LifecycleUnitBase::SetState(State state) {
   if (state == state_)
     return;
-  mojom::LifecycleState previous_state = state_;
   state_ = state;
   for (auto& observer : observers_)
-    observer.OnLifecycleUnitStateChanged(this, previous_state);
+    observer.OnLifecycleUnitStateChanged(this);
 }
 
 void LifecycleUnitBase::OnLifecycleUnitVisibilityChanged(

chrome/browser/resource_coordinator/lifecycle_unit_base.h

@@ -20,14 +20,14 @@ class LifecycleUnitBase : public LifecycleUnit {
 
   // LifecycleUnit:
   int32_t GetID() const override;
-  mojom::LifecycleState GetState() const override;
+  State GetState() const override;
   base::TimeTicks GetLastVisibilityChangeTime() const override;
   void AddObserver(LifecycleUnitObserver* observer) override;
   void RemoveObserver(LifecycleUnitObserver* observer) override;
 
  protected:
   // Sets the state of this LifecycleUnit to |state| and notifies observers.
-  void SetState(mojom::LifecycleState state);
+  void SetState(State state);
 
   // Notifies observers that the visibility of the LifecycleUnit has changed.
   void OnLifecycleUnitVisibilityChanged(content::Visibility visibility);
@@ -44,7 +44,7 @@ class LifecycleUnitBase : public LifecycleUnit {
   const int32_t id_ = ++next_id_;
 
   // Current state of this LifecycleUnit.
-  mojom::LifecycleState state_ = mojom::LifecycleState::kRunning;
+  State state_ = State::LOADED;
 
   base::TimeTicks last_visibility_change_time_;
 

chrome/browser/resource_coordinator/lifecycle_unit_base_unittest.cc

@@ -20,8 +20,7 @@ class MockLifecycleUnitObserver : public LifecycleUnitObserver {
  public:
   MockLifecycleUnitObserver() = default;
 
-  MOCK_METHOD2(OnLifecycleUnitStateChanged,
-               void(LifecycleUnit*, mojom::LifecycleState));
+  MOCK_METHOD1(OnLifecycleUnitStateChanged, void(LifecycleUnit*));
   MOCK_METHOD2(OnLifecycleUnitVisibilityChanged,
                void(LifecycleUnit*, content::Visibility));
   MOCK_METHOD1(OnLifecycleUnitDestroyed, void(LifecycleUnit*));
@@ -47,6 +46,7 @@ class DummyLifecycleUnit : public LifecycleUnitBase {
     return base::ProcessHandle();
   }
   SortKey GetSortKey() const override { return SortKey(); }
+  State GetState() const override { return State::LOADED; }
   content::Visibility GetVisibility() const override {
     return content::Visibility::VISIBLE;
   }
@@ -86,13 +86,12 @@ TEST(LifecycleUnitBaseTest, SetStateNotifiesObservers) {
   lifecycle_unit.AddObserver(&observer);
 
   // Observer is notified when the state changes.
-  EXPECT_CALL(observer, OnLifecycleUnitStateChanged(&lifecycle_unit,
-                                                    lifecycle_unit.GetState()));
-  lifecycle_unit.SetState(mojom::LifecycleState::kDiscarded);
+  EXPECT_CALL(observer, OnLifecycleUnitStateChanged(&lifecycle_unit));
+  lifecycle_unit.SetState(LifecycleUnit::State::DISCARDED);
   testing::Mock::VerifyAndClear(&observer);
 
   // Observer isn't notified when the state stays the same.
-  lifecycle_unit.SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit.SetState(LifecycleUnit::State::DISCARDED);
 
   lifecycle_unit.RemoveObserver(&observer);
 }

chrome/browser/resource_coordinator/lifecycle_unit_observer.cc

@@ -9,8 +9,7 @@ namespace resource_coordinator {
 LifecycleUnitObserver::~LifecycleUnitObserver() = default;
 
 void LifecycleUnitObserver::OnLifecycleUnitStateChanged(
-    LifecycleUnit* lifecycle_unit,
-    mojom::LifecycleState previous_state) {}
+    LifecycleUnit* lifecycle_unit) {}
 
 void LifecycleUnitObserver::OnLifecycleUnitVisibilityChanged(
     LifecycleUnit* lifecycle_unit,

chrome/browser/resource_coordinator/lifecycle_unit_observer.h

@@ -6,7 +6,6 @@
 #define CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_UNIT_OBSERVER_H_
 
 #include "content/public/browser/visibility.h"
-#include "services/resource_coordinator/public/mojom/lifecycle.mojom.h"
 
 namespace resource_coordinator {
 
@@ -18,9 +17,7 @@ class LifecycleUnitObserver {
   virtual ~LifecycleUnitObserver();
 
   // Invoked when the state of the observed LifecycleUnit changes.
-  virtual void OnLifecycleUnitStateChanged(
-      LifecycleUnit* lifecycle_unit,
-      mojom::LifecycleState previous_state);
+  virtual void OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit);
 
   // Invoked when the visibility of the observed LifecyleUnit changes.
   virtual void OnLifecycleUnitVisibilityChanged(LifecycleUnit* lifecycle_unit,

chrome/browser/resource_coordinator/page_signal_receiver.cc

@@ -56,15 +56,6 @@ void PageSignalReceiver::SetExpectedTaskQueueingDuration(
                                                duration);
 }
 
-void PageSignalReceiver::SetLifecycleState(const CoordinationUnitID& cu_id,
-                                           mojom::LifecycleState state) {
-  auto web_contents_iter = cu_id_web_contents_map_.find(cu_id);
-  if (web_contents_iter == cu_id_web_contents_map_.end())
-    return;
-  for (auto& observer : observers_)
-    observer.OnLifecycleStateChanged(web_contents_iter->second, state);
-}
-
 void PageSignalReceiver::AddObserver(PageSignalObserver* observer) {
   // When PageSignalReceiver starts to have observer, construct the mojo
   // channel.

chrome/browser/resource_coordinator/page_signal_receiver.h

@@ -28,8 +28,6 @@ class PageSignalObserver {
   virtual void OnExpectedTaskQueueingDurationSet(
       content::WebContents* web_contents,
       base::TimeDelta duration) {}
-  virtual void OnLifecycleStateChanged(content::WebContents* web_contents,
-                                       mojom::LifecycleState state) {}
 };
 
 // Implementation of resource_coordinator::mojom::PageSignalReceiver.
@@ -52,8 +50,6 @@ class PageSignalReceiver : public mojom::PageSignalReceiver {
   void NotifyPageAlmostIdle(const CoordinationUnitID& cu_id) override;
   void SetExpectedTaskQueueingDuration(const CoordinationUnitID& cu_id,
                                        base::TimeDelta duration) override;
-  void SetLifecycleState(const CoordinationUnitID& cu_id,
-                         mojom::LifecycleState) override;
 
   void AddObserver(PageSignalObserver* observer);
   void RemoveObserver(PageSignalObserver* observer);

chrome/browser/resource_coordinator/tab_lifecycle_unit.cc

@@ -56,8 +56,8 @@ void TabLifecycleUnitSource::TabLifecycleUnit::SetFocused(bool focused) {
     return;
   last_focused_time_ = focused ? base::TimeTicks::Max() : NowTicks();
 
-  if (focused && GetState() == mojom::LifecycleState::kDiscarded) {
-    SetState(mojom::LifecycleState::kRunning);
+  if (focused && GetState() == State::DISCARDED) {
+    SetState(State::LOADED);
     // See comment in Discard() for an explanation of why "needs reload" is
     // false when a tab is discarded.
     // TODO(fdoray): Remove NavigationControllerImpl::needs_reload_ once session
@@ -76,12 +76,6 @@ void TabLifecycleUnitSource::TabLifecycleUnit::SetRecentlyAudible(
     recently_audible_time_ = NowTicks();
 }
 
-void TabLifecycleUnitSource::TabLifecycleUnit::UpdateLifecycleState(
-    mojom::LifecycleState state) {
-  DCHECK_NE(mojom::LifecycleState::kDiscarded, state);
-  SetState(state);
-}
-
 TabLifecycleUnitExternal*
 TabLifecycleUnitSource::TabLifecycleUnit::AsTabLifecycleUnitExternal() {
   return this;
@@ -113,8 +107,9 @@ content::Visibility TabLifecycleUnitSource::TabLifecycleUnit::GetVisibility()
 }
 
 bool TabLifecycleUnitSource::TabLifecycleUnit::Freeze() {
-  // Can't request to freeze a discarded tab.
-  if (IsDiscarded())
+  // Can't freeze tabs that are already discarded or frozen.
+  // TODO(fmeawad): Don't freeze already frozen tabs.
+  if (GetState() != State::LOADED)
     return false;
 
   GetWebContents()->FreezePage();
@@ -278,7 +273,7 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::Discard(
   // RenderFrameProxyHosts.
   old_contents_deleter.reset();
 
-  SetState(mojom::LifecycleState::kDiscarded);
+  SetState(State::DISCARDED);
   ++discard_count_;
   OnDiscardedStateChange();
 
@@ -334,11 +329,7 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::FreezeTab() {
 }
 
 bool TabLifecycleUnitSource::TabLifecycleUnit::IsDiscarded() const {
-  return GetState() == mojom::LifecycleState::kDiscarded;
-}
-
-bool TabLifecycleUnitSource::TabLifecycleUnit::IsFrozen() const {
-  return GetState() == mojom::LifecycleState::kFrozen;
+  return GetState() == State::DISCARDED;
 }
 
 int TabLifecycleUnitSource::TabLifecycleUnit::GetDiscardCount() const {
@@ -356,8 +347,8 @@ TabLifecycleUnitSource::TabLifecycleUnit::GetRenderProcessHost() const {
 }
 
 void TabLifecycleUnitSource::TabLifecycleUnit::DidStartLoading() {
-  if (IsDiscarded()) {
-    SetState(mojom::LifecycleState::kRunning);
+  if (GetState() == State::DISCARDED) {
+    SetState(State::LOADED);
     OnDiscardedStateChange();
   }
 }

chrome/browser/resource_coordinator/tab_lifecycle_unit.h

@@ -86,17 +86,8 @@ class TabLifecycleUnitSource::TabLifecycleUnit
   bool FreezeTab() override;
   bool DiscardTab() override;
   bool IsDiscarded() const override;
-  bool IsFrozen() const override;
   int GetDiscardCount() const override;
 
- protected:
-  // TabLifecycleUnitSource needs to update the state when a external lifecycle
-  // state change is observed.
-  friend class TabLifecycleUnitSource;
-  // Updates the tab's lifecycle state when changed outside the tab lifecycle
-  // unit.
-  void UpdateLifecycleState(mojom::LifecycleState state);
-
  private:
   // Invoked when the state goes from DISCARDED to non-DISCARDED and vice-versa.
   void OnDiscardedStateChange();

chrome/browser/resource_coordinator/tab_lifecycle_unit_external.h

@@ -51,9 +51,6 @@ class TabLifecycleUnitExternal {
   // Returns true if the tab is discarded.
   virtual bool IsDiscarded() const = 0;
 
-  // Returns true if the tab is frozen.
-  virtual bool IsFrozen() const = 0;
-
   // Returns the number of times that the tab was discarded.
   virtual int GetDiscardCount() const = 0;
 };

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.cc

@@ -53,15 +53,9 @@ TabLifecycleUnitSource::TabLifecycleUnitSource()
   DCHECK(BrowserList::GetInstance()->empty());
   browser_tab_strip_tracker_.Init();
   instance_ = this;
-  // TODO(chrisha): Create a ScopedPageSignalObserver helper class to clean up
-  // this manual lifetime management.
-  if (auto* page_signal_receiver = PageSignalReceiver::GetInstance())
-    page_signal_receiver->AddObserver(this);
 }
 
 TabLifecycleUnitSource::~TabLifecycleUnitSource() {
-  if (auto* page_signal_receiver = PageSignalReceiver::GetInstance())
-    page_signal_receiver->RemoveObserver(this);
   DCHECK_EQ(instance_, this);
   instance_ = nullptr;
 }
@@ -215,17 +209,6 @@ void TabLifecycleUnitSource::OnBrowserNoLongerActive(Browser* browser) {
   UpdateFocusedTab();
 }
 
-void TabLifecycleUnitSource::OnLifecycleStateChanged(
-    content::WebContents* web_contents,
-    mojom::LifecycleState state) {
-  TabLifecycleUnit* lifecycle_unit = GetTabLifecycleUnit(web_contents);
-
-  // Some WebContents aren't attached to a tab, so there is no corresponding
-  // TabLifecycleUnit.
-  if (lifecycle_unit)
-    lifecycle_unit->UpdateLifecycleState(state);
-}
-
 }  // namespace resource_coordinator
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.h

@@ -10,7 +10,6 @@
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "chrome/browser/resource_coordinator/lifecycle_unit_source_base.h"
-#include "chrome/browser/resource_coordinator/page_signal_receiver.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/browser_tab_strip_tracker.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
@@ -29,7 +28,6 @@ class TabLifecycleUnitExternal;
 // Creates and destroys LifecycleUnits as tabs are created and destroyed.
 class TabLifecycleUnitSource : public BrowserListObserver,
                                public LifecycleUnitSourceBase,
-                               public PageSignalObserver,
                                public TabStripModelObserver {
  public:
   TabLifecycleUnitSource();
@@ -96,10 +94,6 @@ class TabLifecycleUnitSource : public BrowserListObserver,
   void OnBrowserSetLastActive(Browser* browser) override;
   void OnBrowserNoLongerActive(Browser* browser) override;
 
-  // PageSignalObserver:
-  void OnLifecycleStateChanged(content::WebContents* web_contents,
-                               mojom::LifecycleState state) override;
-
   // Tracks the BrowserList and all TabStripModels.
   BrowserTabStripTracker browser_tab_strip_tracker_;
 

chrome/browser/resource_coordinator/tab_lifecycle_unit_source_unittest.cc

@@ -69,8 +69,8 @@ class MockLifecycleUnitObserver : public LifecycleUnitObserver {
  public:
   MockLifecycleUnitObserver() = default;
 
-  MOCK_METHOD2(OnLifecycleUnitStateChanged,
-               void(LifecycleUnit* lifecycle_unit, mojom::LifecycleState));
+  MOCK_METHOD1(OnLifecycleUnitStateChanged,
+               void(LifecycleUnit* lifecycle_unit));
   MOCK_METHOD2(OnLifecycleUnitVisibilityChanged,
                void(LifecycleUnit* lifecycle_unit,
                     content::Visibility visibility));
@@ -359,12 +359,11 @@ TEST_F(TabLifecycleUnitSourceTest, DetachWebContents) {
   other_tab_strip_model.AppendWebContents(std::move(owned_contents), false);
   EXPECT_FOR_ALL_DISCARD_REASONS(first_lifecycle_unit, CanDiscard, true);
 
-  EXPECT_EQ(mojom::LifecycleState::kRunning, first_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleUnit::State::LOADED, first_lifecycle_unit->GetState());
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
   first_lifecycle_unit->Discard(DiscardReason::kProactive);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
-            first_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleUnit::State::DISCARDED, first_lifecycle_unit->GetState());
 
   // Expect a notification when the tab is closed.
   CloseTabsAndExpectNotifications(&other_tab_strip_model,
@@ -410,14 +409,14 @@ TEST_F(TabLifecycleUnitSourceTest, Discard) {
   initial_web_contents->SetLastActiveTime(kDummyLastActiveTime);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
   background_lifecycle_unit->Discard(DiscardReason::kProactive);
   testing::Mock::VerifyAndClear(&tab_observer_);
 
   // Expect the tab to be discarded and the last active time to be preserved.
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
+  EXPECT_EQ(LifecycleUnit::State::DISCARDED,
             background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
@@ -437,12 +436,12 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndActivate) {
       tab_strip_model_->GetWebContentsAt(0);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
   background_lifecycle_unit->Discard(DiscardReason::kProactive);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
+  EXPECT_EQ(LifecycleUnit::State::DISCARDED,
             background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
@@ -452,7 +451,7 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndActivate) {
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, false));
   tab_strip_model_->ActivateTabAt(0, true);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -467,12 +466,12 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndExplicitlyReload) {
       tab_strip_model_->GetWebContentsAt(0);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
   background_lifecycle_unit->Discard(DiscardReason::kProactive);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
+  EXPECT_EQ(LifecycleUnit::State::DISCARDED,
             background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
@@ -483,7 +482,7 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndExplicitlyReload) {
   tab_strip_model_->GetWebContentsAt(0)->GetController().Reload(
       content::ReloadType::NORMAL, false);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -501,12 +500,12 @@ TEST_F(TabLifecycleUnitSourceTest, CanOnlyDiscardOnce) {
   EXPECT_FOR_ALL_DISCARD_REASONS(background_lifecycle_unit, CanDiscard, true);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
   background_lifecycle_unit->Discard(DiscardReason::kProactive);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
+  EXPECT_EQ(LifecycleUnit::State::DISCARDED,
             background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
@@ -517,7 +516,7 @@ TEST_F(TabLifecycleUnitSourceTest, CanOnlyDiscardOnce) {
   tab_strip_model_->GetWebContentsAt(0)->GetController().Reload(
       content::ReloadType::NORMAL, false);
   testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
+  EXPECT_EQ(LifecycleUnit::State::LOADED,
             background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -534,44 +533,4 @@ TEST_F(TabLifecycleUnitSourceTest, CanOnlyDiscardOnce) {
 #endif
 }
 
-TEST_F(TabLifecycleUnitSourceTest, CannotFreezeADiscardedTab) {
-  LifecycleUnit* background_lifecycle_unit = nullptr;
-  LifecycleUnit* foreground_lifecycle_unit = nullptr;
-  CreateTwoTabs(true /* focus_tab_strip */, &background_lifecycle_unit,
-                &foreground_lifecycle_unit);
-  content::WebContents* initial_web_contents =
-      tab_strip_model_->GetWebContentsAt(0);
-  test_clock_.Advance(kShortDelay);
-
-  // It should be possible to discard the background tab.
-  EXPECT_FOR_ALL_DISCARD_REASONS(background_lifecycle_unit, CanDiscard, true);
-
-  // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
-  EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, true));
-  background_lifecycle_unit->Discard(DiscardReason::kProactive);
-  testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kDiscarded,
-            background_lifecycle_unit->GetState());
-  EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
-  EXPECT_FALSE(
-      tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
-
-  EXPECT_FALSE(background_lifecycle_unit->Freeze());
-
-  // Explicitly reload the tab. Expect the state to be LOADED.
-  EXPECT_CALL(tab_observer_, OnDiscardedStateChange(testing::_, false));
-  tab_strip_model_->GetWebContentsAt(0)->GetController().Reload(
-      content::ReloadType::NORMAL, false);
-  testing::Mock::VerifyAndClear(&tab_observer_);
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
-  EXPECT_TRUE(
-      tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
-
-  // Should be able to freeze the reloaded tab.
-  EXPECT_TRUE(background_lifecycle_unit->Freeze());
-}
-
 }  // namespace resource_coordinator

chrome/browser/resource_coordinator/tab_lifecycle_unit_unittest.cc

@@ -52,8 +52,7 @@ class MockLifecycleUnitObserver : public LifecycleUnitObserver {
  public:
   MockLifecycleUnitObserver() = default;
 
-  MOCK_METHOD2(OnLifecycleUnitStateChanged,
-               void(LifecycleUnit*, mojom::LifecycleState));
+  MOCK_METHOD1(OnLifecycleUnitStateChanged, void(LifecycleUnit*));
   MOCK_METHOD1(OnLifecycleUnitDestroyed, void(LifecycleUnit*));
   MOCK_METHOD2(OnLifecycleUnitVisibilityChanged,
                void(LifecycleUnit*, content::Visibility));

chrome/browser/resource_coordinator/tab_manager.cc

@@ -119,7 +119,7 @@ std::unique_ptr<base::trace_event::ConvertableToTraceFormat> DataAsTraceValue(
 int GetNumLoadedLifecycleUnits(LifecycleUnitSet lifecycle_unit_set) {
   int num_loaded_lifecycle_units = 0;
   for (auto* lifecycle_unit : lifecycle_unit_set)
-    if (lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded)
+    if (lifecycle_unit->GetState() == LifecycleUnit::State::LOADED)
       num_loaded_lifecycle_units++;
   return num_loaded_lifecycle_units;
 }
@@ -1026,13 +1026,11 @@ void TabManager::UpdateProactiveDiscardTimerIfNecessary() {
           next_to_discard, this));
 }
 
-void TabManager::OnLifecycleUnitStateChanged(
-    LifecycleUnit* lifecycle_unit,
-    mojom::LifecycleState previous_state) {
-  if (lifecycle_unit->GetState() == mojom::LifecycleState::kDiscarded)
-    num_loaded_lifecycle_units_--;
-  else if (previous_state == mojom::LifecycleState::kDiscarded)
+void TabManager::OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit) {
+  if (lifecycle_unit->GetState() == LifecycleUnit::State::LOADED)
     num_loaded_lifecycle_units_++;
+  else
+    num_loaded_lifecycle_units_--;
 
   DCHECK_EQ(num_loaded_lifecycle_units_,
             GetNumLoadedLifecycleUnits(lifecycle_units_));
@@ -1047,7 +1045,7 @@ void TabManager::OnLifecycleUnitVisibilityChanged(
 }
 
 void TabManager::OnLifecycleUnitDestroyed(LifecycleUnit* lifecycle_unit) {
-  if (lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded)
+  if (lifecycle_unit->GetState() == LifecycleUnit::State::LOADED)
     num_loaded_lifecycle_units_--;
   lifecycle_units_.erase(lifecycle_unit);
 
@@ -1059,7 +1057,8 @@ void TabManager::OnLifecycleUnitDestroyed(LifecycleUnit* lifecycle_unit) {
 
 void TabManager::OnLifecycleUnitCreated(LifecycleUnit* lifecycle_unit) {
   lifecycle_units_.insert(lifecycle_unit);
-  if (lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded)
+
+  if (lifecycle_unit->GetState() == LifecycleUnit::State::LOADED)
     num_loaded_lifecycle_units_++;
 
   // Add an observer to be notified of destruction.

chrome/browser/resource_coordinator/tab_manager.h

@@ -427,9 +427,7 @@ class TabManager : public LifecycleUnitObserver,
       LifecycleUnit* lifecycle_unit,
       content::Visibility visibility) override;
   void OnLifecycleUnitDestroyed(LifecycleUnit* lifecycle_unit) override;
-  void OnLifecycleUnitStateChanged(
-      LifecycleUnit* lifecycle_unit,
-      mojom::LifecycleState previous_state) override;
+  void OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit) override;
 
   // LifecycleUnitSourceObserver:
   void OnLifecycleUnitCreated(LifecycleUnit* lifecycle_unit) override;

chrome/browser/resource_coordinator/tab_manager_delegate_chromeos_unittest.cc

@@ -48,6 +48,7 @@ class DummyLifecycleUnit : public LifecycleUnitBase {
     return nullptr;
   }
   SortKey GetSortKey() const override { return SortKey(last_focused_time_); }
+  State GetState() const override { return State::LOADED; }
   content::Visibility GetVisibility() const override {
     return content::Visibility::VISIBLE;
   }

chrome/browser/resources/discards/discards.html

@@ -37,7 +37,6 @@ general use and is not localized.
           <th data-sort-key="tabUrl">Tab URL</th>
           <th data-sort-key="visibility">Visibility</th>
           <th data-sort-key="isMedia">Media</th>
-          <th data-sort-key="isFrozen">Frozen</th>
           <th data-sort-key="isDiscarded">Discarded</th>
           <th data-sort-key="discardCount">Discard Count</th>
           <th data-sort-key="isAutoDiscardable">Auto Discardable</th>
@@ -59,7 +58,6 @@ general use and is not localized.
         <td class="tab-url-cell"></td>
         <td class="visibility-cell"></td>
         <td class="is-media-cell boolean-cell"></td>
-        <td class="is-frozen-cell boolean-cell"></td>
         <td class="is-discarded-cell boolean-cell"></td>
         <td class="discard-count-cell"></td>
         <td class="is-auto-discardable-cell boolean-cell">

chrome/browser/resources/discards/discards.js

@@ -64,8 +64,7 @@ cr.define('discards', function() {
     }
 
     // Compares boolean fields.
-    if (['isMedia', 'isFrozen', 'isDiscarded', 'isAutoDiscardable'].includes(
-            sortKey)) {
+    if (['isMedia', 'isDiscarded', 'isAutoDiscardable'].includes(sortKey)) {
       if (val1 == val2)
         return 0;
       return val1 ? 1 : -1;
@@ -255,6 +254,8 @@ cr.define('discards', function() {
     let lifecycleListener = function(e) {
       // Get the info backing this row.
       let info = infos[getRowIndex(e.target)];
+      // TODO(fmeawad): Disable the action, and let the update function
+      // re-enable it. Blocked on acquiring freeze status.
       // Perform the action.
       uiHandler.freezeById(info.id);
     };
@@ -281,8 +282,6 @@ cr.define('discards', function() {
         visibilityToString(info.visibility);
     row.querySelector('.is-media-cell').textContent =
         boolToString(info.isMedia);
-    row.querySelector('.is-frozen-cell').textContent =
-        boolToString(info.isFrozen);
     row.querySelector('.is-discarded-cell').textContent =
         boolToString(info.isDiscarded);
     row.querySelector('.discard-count-cell').textContent =
@@ -303,12 +302,6 @@ cr.define('discards', function() {
       discardLink.removeAttribute('disabled');
       discardUrgentLink.removeAttribute('disabled');
     }
-
-    let freezeLink = row.querySelector('.freeze-link');
-    if (info.isFrozen)
-      freezeLink.setAttribute('disabled', '');
-    else
-      freezeLink.removeAttribute('disabled', '');
   }
 
   /**

chrome/browser/ui/webui/discards/discards.mojom

@@ -25,11 +25,6 @@ struct TabDiscardsInfo {
   bool is_media;
   // If the tab is currently discarded, this is true.
   bool is_discarded;
-  // If the tab is currently frozen, this is true.
-  // TODO(fmeawad): is_discarded and is_frozen are mutually exclusive, instead
-  // of representing each individually, we should add a "lifecycle_state" field
-  // instead.
-  bool is_frozen;
   // The number of times this tab has been discarded in the current browser
   // session.
   int32 discard_count;

chrome/browser/ui/webui/discards/discards_ui.cc

@@ -87,7 +87,6 @@ class DiscardsDetailsProviderImpl : public mojom::DiscardsDetailsProvider {
       info->visibility =
           GetLifecycleUnitVisibility(lifecycle_unit->GetVisibility());
       info->is_media = tab_lifecycle_unit_external->IsMediaTab();
-      info->is_frozen = tab_lifecycle_unit_external->IsFrozen();
       info->is_discarded = tab_lifecycle_unit_external->IsDiscarded();
       info->discard_count = tab_lifecycle_unit_external->GetDiscardCount();
       info->utility_rank = rank++;

chrome/test/data/webui/discards/discards_browsertest.js

@@ -22,7 +22,6 @@ TEST_F('DiscardsTest', 'CompareTabDiscardsInfo', function() {
     tabUrl: 'http://urlone.com',
     visibility: 0,
     isMedia: false,
-    isFrozen: false,
     isDiscarded: false,
     isAutoDiscardable: false,
     discardCount: 0,
@@ -34,7 +33,6 @@ TEST_F('DiscardsTest', 'CompareTabDiscardsInfo', function() {
     tabUrl: 'http://urltwo.com',
     visibility: 1,
     isMedia: true,
-    isFrozen: true,
     isDiscarded: true,
     isAutoDiscardable: true,
     discardCount: 1,
@@ -42,7 +40,7 @@ TEST_F('DiscardsTest', 'CompareTabDiscardsInfo', function() {
     lastActiveSeconds: 1
   };
 
-  ['title', 'tabUrl', 'visibility', 'isMedia', 'isFrozen', 'isDiscarded',
+  ['title', 'tabUrl', 'visibility', 'isMedia', 'isDiscarded',
       'isAutoDiscardable', 'discardCount', 'utilityRank', 'lastActiveSeconds']
       .forEach((sortKey) => {
     assertTrue(

services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.cc

@@ -68,16 +68,6 @@ void FrameCoordinationUnitImpl::SetNetworkAlmostIdle(bool idle) {
   SetProperty(mojom::PropertyType::kNetworkAlmostIdle, idle);
 }
 
-void FrameCoordinationUnitImpl::SetLifecycleState(mojom::LifecycleState state) {
-  SetProperty(mojom::PropertyType::kLifecycleState,
-              static_cast<int64_t>(state));
-  // The page will have the same lifecycle state as the main frame.
-  if (IsMainFrame() && GetPageCoordinationUnit()) {
-    GetPageCoordinationUnit()->SetProperty(mojom::PropertyType::kLifecycleState,
-                                           static_cast<int64_t>(state));
-  }
-}
-
 void FrameCoordinationUnitImpl::OnAlertFired() {
   SendEvent(mojom::Event::kAlertFired);
 }

services/resource_coordinator/coordination_unit/frame_coordination_unit_impl.h

@@ -33,7 +33,6 @@ class FrameCoordinationUnitImpl
   void RemoveChildFrame(const CoordinationUnitID& cu_id) override;
   void SetAudibility(bool audible) override;
   void SetNetworkAlmostIdle(bool idle) override;
-  void SetLifecycleState(mojom::LifecycleState state) override;
   void OnAlertFired() override;
   void OnNonPersistentNotificationCreated() override;
 

services/resource_coordinator/coordination_unit/frame_coordination_unit_impl_unittest.cc

@@ -7,7 +7,6 @@
 #include "base/test/simple_test_tick_clock.h"
 #include "services/resource_coordinator/coordination_unit/coordination_unit_test_harness.h"
 #include "services/resource_coordinator/coordination_unit/mock_coordination_unit_graphs.h"
-#include "services/resource_coordinator/coordination_unit/page_coordination_unit_impl.h"
 #include "services/resource_coordinator/coordination_unit/process_coordination_unit_impl.h"
 #include "services/resource_coordinator/resource_coordinator_clock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -124,61 +123,4 @@ TEST_F(FrameCoordinationUnitImplTest, LastAudibleTime) {
             cu_graph.frame->last_audible_time());
 }
 
-int64_t GetLifecycleState(resource_coordinator::CoordinationUnitBase* cu) {
-  int64_t value;
-  if (cu->GetProperty(mojom::PropertyType::kLifecycleState, &value))
-    return value;
-  // Initial state is running.
-  return static_cast<int64_t>(mojom::LifecycleState::kRunning);
-}
-
-#define EXPECT_FROZEN(cu)                                         \
-  EXPECT_EQ(static_cast<int64_t>(mojom::LifecycleState::kFrozen), \
-            GetLifecycleState(cu.get()))
-#define EXPECT_RUNNING(cu)                                         \
-  EXPECT_EQ(static_cast<int64_t>(mojom::LifecycleState::kRunning), \
-            GetLifecycleState(cu.get()))
-
-TEST_F(FrameCoordinationUnitImplTest, LifecycleStatesTransitions) {
-  MockMultiplePagesWithMultipleProcessesCoordinationUnitGraph cu_graph;
-  // Verifying the model.
-  ASSERT_TRUE(cu_graph.frame->IsMainFrame());
-  ASSERT_TRUE(cu_graph.other_frame->IsMainFrame());
-  ASSERT_FALSE(cu_graph.child_frame->IsMainFrame());
-  ASSERT_EQ(cu_graph.child_frame->GetParentFrameCoordinationUnit(),
-            cu_graph.other_frame.get());
-  ASSERT_EQ(cu_graph.frame->GetPageCoordinationUnit(), cu_graph.page.get());
-  ASSERT_EQ(cu_graph.other_frame->GetPageCoordinationUnit(),
-            cu_graph.other_page.get());
-
-  // Freezing a child frame should not affect the page state.
-  cu_graph.child_frame->SetLifecycleState(mojom::LifecycleState::kFrozen);
-  // Verify that the frame is frozen.
-  EXPECT_FROZEN(cu_graph.child_frame);
-  // But all pages remain active.
-  EXPECT_RUNNING(cu_graph.page);
-  EXPECT_RUNNING(cu_graph.other_page);
-
-  // Freezing a page main frame should freeze that page.
-  cu_graph.frame->SetLifecycleState(mojom::LifecycleState::kFrozen);
-  EXPECT_FROZEN(cu_graph.frame);
-  EXPECT_FROZEN(cu_graph.page);
-
-  // Freezing the other page main frame.
-  cu_graph.other_frame->SetLifecycleState(mojom::LifecycleState::kFrozen);
-  EXPECT_FROZEN(cu_graph.other_frame);
-  EXPECT_FROZEN(cu_graph.other_page);
-
-  // Unfreezing subframe should have no effect.
-  cu_graph.child_frame->SetLifecycleState(mojom::LifecycleState::kRunning);
-  // Verify that the frame is unfrozen.
-  EXPECT_RUNNING(cu_graph.child_frame);
-  // But the page is still frozen
-  EXPECT_FROZEN(cu_graph.other_page);
-
-  // Unfreezing the main frame should unfreeze the page.
-  cu_graph.other_frame->SetLifecycleState(mojom::LifecycleState::kRunning);
-  EXPECT_RUNNING(cu_graph.other_page);
-}
-
 }  // namespace resource_coordinator

services/resource_coordinator/observers/page_signal_generator_impl.cc

@@ -46,24 +46,17 @@ void PageSignalGeneratorImpl::AddReceiver(
   receivers_.AddPtr(std::move(receiver));
 }
 
-// Frame CUs should be observed for:
-// 1- kNetworkAlmostIdle property changes used for PageAlmostIdle detection
-// Page CUs should be observed for:
-// 1- kLoading property changes used for PageAlmostIdle detection
-// 2- kLifecycleState property changes used to update the Tab lifecycle state
-// 3- kNavigationCommitted events for PageAlmostIdle detection
-// Process CUs should be observed for:
-// 1- kExpectedTaskQueueingDuration property for reporting EQT
-// 2- kMainThreadTaskLoadIsLow property changes for PageAlmostIdle detection
 bool PageSignalGeneratorImpl::ShouldObserve(
     const CoordinationUnitBase* coordination_unit) {
   auto cu_type = coordination_unit->id().type;
-  if (cu_type == CoordinationUnitType::kProcess ||
-      cu_type == CoordinationUnitType::kPage)
+  // Always tracked process CUs. This is used for CPU utilization messages.
+  if (cu_type == CoordinationUnitType::kProcess)
     return true;
   if (!resource_coordinator::IsPageAlmostIdleSignalEnabled())
     return false;
-  return cu_type == CoordinationUnitType::kFrame;
+  // Frame and page CUs are only used for PAI.
+  return cu_type == CoordinationUnitType::kFrame ||
+         cu_type == CoordinationUnitType::kPage;
 }
 
 void PageSignalGeneratorImpl::OnCoordinationUnitCreated(
@@ -111,12 +104,12 @@ void PageSignalGeneratorImpl::OnPagePropertyChanged(
     const PageCoordinationUnitImpl* page_cu,
     const mojom::PropertyType property_type,
     int64_t value) {
-  if (resource_coordinator::IsPageAlmostIdleSignalEnabled() &&
-      property_type == mojom::PropertyType::kIsLoading) {
-    UpdateLoadIdleStatePage(page_cu);
-  } else if (property_type == mojom::PropertyType::kLifecycleState) {
-    UpdateLifecycleState(page_cu, static_cast<mojom::LifecycleState>(value));
-  }
+  DCHECK(resource_coordinator::IsPageAlmostIdleSignalEnabled());
+
+  // Only the loading state of a page is of interest.
+  if (property_type != mojom::PropertyType::kIsLoading)
+    return;
+  UpdateLoadIdleStatePage(page_cu);
 }
 
 void PageSignalGeneratorImpl::OnProcessPropertyChanged(
@@ -146,9 +139,7 @@ void PageSignalGeneratorImpl::OnProcessPropertyChanged(
 void PageSignalGeneratorImpl::OnPageEventReceived(
     const PageCoordinationUnitImpl* page_cu,
     const mojom::Event event) {
-  // We only care about the events if network idle signal is enabled.
-  if (!resource_coordinator::IsPageAlmostIdleSignalEnabled())
-    return;
+  DCHECK(resource_coordinator::IsPageAlmostIdleSignalEnabled());
 
   // Only the navigation committed event is of interest.
   if (event != mojom::Event::kNavigationCommitted)
@@ -277,12 +268,6 @@ void PageSignalGeneratorImpl::UpdateLoadIdleStateProcess(
     UpdateLoadIdleStateFrame(frame_cu);
 }
 
-void PageSignalGeneratorImpl::UpdateLifecycleState(
-    const PageCoordinationUnitImpl* page_cu,
-    const mojom::LifecycleState state) {
-  DISPATCH_PAGE_SIGNAL(receivers_, SetLifecycleState, page_cu->id(), state);
-}
-
 void PageSignalGeneratorImpl::TransitionToLoadedAndIdle(
     const PageCoordinationUnitImpl* page_cu) {
   DCHECK(resource_coordinator::IsPageAlmostIdleSignalEnabled());

services/resource_coordinator/observers/page_signal_generator_impl.h

@@ -126,11 +126,6 @@ class PageSignalGeneratorImpl : public CoordinationUnitGraphObserver,
   void UpdateLoadIdleStateProcess(
       const ProcessCoordinationUnitImpl* process_cu);
 
-  // This method is called when a property affecting the lifecycle state is
-  // observed.
-  void UpdateLifecycleState(const PageCoordinationUnitImpl* page_cu,
-                            mojom::LifecycleState state);
-
   // Helper function for transitioning to the final state.
   void TransitionToLoadedAndIdle(const PageCoordinationUnitImpl* page_cu);
 

services/resource_coordinator/public/mojom/BUILD.gn

@@ -12,7 +12,6 @@ mojom_component("mojom") {
     "coordination_unit.mojom",
     "coordination_unit_introspector.mojom",
     "coordination_unit_provider.mojom",
-    "lifecycle.mojom",
     "memory_instrumentation/constants.mojom",
     "memory_instrumentation/memory_instrumentation.mojom",
     "page_signal.mojom",

services/resource_coordinator/public/mojom/coordination_unit.mojom

@@ -6,7 +6,6 @@ module resource_coordinator.mojom;
 
 import "mojo/public/mojom/base/process_id.mojom";
 import "mojo/public/mojom/base/time.mojom";
-import "services/resource_coordinator/public/mojom/lifecycle.mojom";
 import "services/resource_coordinator/public/mojom/signals.mojom";
 
 // Any new type here needs to be mirrored between coordination_unit_types.h and
@@ -65,7 +64,6 @@ interface FrameCoordinationUnit {
   // Property signals.
   SetAudibility(bool audible);
   SetNetworkAlmostIdle(bool idle);
-  SetLifecycleState(LifecycleState state);
 
   // Event signals.
   OnAlertFired();

services/resource_coordinator/public/mojom/lifecycle.mojom

-// Copyright 2018 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.
-
-module resource_coordinator.mojom;
-
-// A lifecycle unit (a page, frame, tab or application) can be in one of
-// these lifecycle states.
-enum LifecycleState {
-  kRunning,
-  kFrozen,
-  kDiscarded
-};
\ No newline at end of file

services/resource_coordinator/public/mojom/page_signal.mojom

@@ -5,7 +5,6 @@
 module resource_coordinator.mojom;
 
 import "services/resource_coordinator/public/mojom/coordination_unit.mojom";
-import "services/resource_coordinator/public/mojom/lifecycle.mojom";
 import "mojo/public/mojom/base/time.mojom";
 
 // A PageSignalReceiver implementation receives page-scoped signal from
@@ -18,8 +17,6 @@ interface PageSignalReceiver {
   NotifyPageAlmostIdle(CoordinationUnitID cu_id);
   SetExpectedTaskQueueingDuration(CoordinationUnitID cu_id,
                                   mojo_base.mojom.TimeDelta duration);
-  SetLifecycleState(CoordinationUnitID cu_id,
-                    LifecycleState state);
 };
 
 // A PageSignalGenerator implementation will be implemented inside GRC to receive

services/resource_coordinator/public/mojom/signals.mojom

@@ -36,5 +36,4 @@ enum PropertyType {
   kUKMSourceId,
   // Used by Page CUs to store current loading state.
   kIsLoading,
-  kLifecycleState,
 };

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

@@ -539,12 +539,6 @@ void LocalFrame::DidFreeze() {
         CustomCountHistogram, freeze_histogram,
         ("DocumentEventTiming.FreezeDuration", 0, 10000000, 50));
     freeze_histogram.Count((freeze_event_end - freeze_event_start) * 1000000.0);
-    // TODO(fmeawad): Move the following logic to the page once we have a
-    // PageResourceCoordinator in Blink. http://crbug.com/838415
-    if (auto* frame_resource_coordinator = GetFrameResourceCoordinator()) {
-      frame_resource_coordinator->SetLifecycleState(
-          resource_coordinator::mojom::LifecycleState::kFrozen);
-    }
   }
 }
 
@@ -558,12 +552,6 @@ void LocalFrame::DidResume() {
         CustomCountHistogram, resume_histogram,
         ("DocumentEventTiming.ResumeDuration", 0, 10000000, 50));
     resume_histogram.Count((resume_event_end - resume_event_start) * 1000000.0);
-    // TODO(fmeawad): Move the following logic to the page once we have a
-    // PageResourceCoordinator in Blink
-    if (auto* frame_resource_coordinator = GetFrameResourceCoordinator()) {
-      frame_resource_coordinator->SetLifecycleState(
-          resource_coordinator::mojom::LifecycleState::kRunning);
-    }
   }
 }
 

third_party/blink/renderer/platform/instrumentation/resource_coordinator/frame_resource_coordinator.cc

@@ -27,13 +27,6 @@ void FrameResourceCoordinator::SetNetworkAlmostIdle(bool idle) {
   service_->SetNetworkAlmostIdle(idle);
 }
 
-void FrameResourceCoordinator::SetLifecycleState(
-    resource_coordinator::mojom::LifecycleState state) {
-  if (!service_)
-    return;
-  service_->SetLifecycleState(state);
-}
-
 void FrameResourceCoordinator::OnNonPersistentNotificationCreated() {
   if (!service_)
     return;

third_party/blink/renderer/platform/instrumentation/resource_coordinator/frame_resource_coordinator.h

@@ -23,7 +23,6 @@ class PLATFORM_EXPORT FrameResourceCoordinator final
   ~FrameResourceCoordinator();
 
   void SetNetworkAlmostIdle(bool);
-  void SetLifecycleState(resource_coordinator::mojom::LifecycleState);
   void OnNonPersistentNotificationCreated();
 
  private: