Refactor to have a LifecycleState separate from the mojom::LifecycleState

This refactor was done to allow for greater granularity for internal LifecycleUnit state representation.

Change-Id: I27c20eec8e5fe7f1365b64fe87b32cfdf124fbb8
Reviewed-on: https://chromium-review.googlesource.com/1041010
Commit-Queue: Varun Mohan <varunmohan@google.com>
Reviewed-by: François Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556109}

chrome/browser/resource_coordinator/discard_metrics_lifecycle_unit_observer.cc

@@ -19,10 +19,10 @@ DiscardMetricsLifecycleUnitObserver::~DiscardMetricsLifecycleUnitObserver() =
 
 void DiscardMetricsLifecycleUnitObserver::OnLifecycleUnitStateChanged(
     LifecycleUnit* lifecycle_unit,
-    mojom::LifecycleState previous_state) {
-  if (lifecycle_unit->GetState() == mojom::LifecycleState::kDiscarded)
+    LifecycleState last_state) {
+  if (lifecycle_unit->GetState() == LifecycleState::DISCARDED)
     OnDiscard(lifecycle_unit);
-  else if (previous_state == mojom::LifecycleState::kDiscarded)
+  else if (last_state == LifecycleState::DISCARDED)
     OnReload();
 }
 
@@ -31,7 +31,7 @@ void DiscardMetricsLifecycleUnitObserver::OnLifecycleUnitDestroyed(
   // If the browser is not shutting down and the tab is loaded after
   // being discarded, record TabManager.Discarding.ReloadToCloseTime.
   if (g_browser_process && !g_browser_process->IsShuttingDown() &&
-      lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded &&
+      lifecycle_unit->GetState() != LifecycleState::DISCARDED &&
       !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

@@ -9,6 +9,7 @@
 
 #include "base/macros.h"
 #include "base/time/time.h"
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 
 namespace resource_coordinator {
 
@@ -19,9 +20,8 @@ class DiscardMetricsLifecycleUnitObserver : public LifecycleUnitObserver {
   ~DiscardMetricsLifecycleUnitObserver() override;
 
   // LifecycleUnitObserver:
-  void OnLifecycleUnitStateChanged(
-      LifecycleUnit* lifecycle_unit,
-      mojom::LifecycleState previous_state) override;
+  void OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit,
+                                   LifecycleState last_state) 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(LifecycleState::DISCARDED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 1);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleState::ACTIVE);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 1);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 1);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit_->SetState(LifecycleState::DISCARDED);
   histograms_.ExpectTotalCount(kDiscardCountHistogram, 2);
   histograms_.ExpectTotalCount(kReloadCountHistogram, 1);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleState::ACTIVE);
   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(LifecycleState::DISCARDED);
   test_clock_.Advance(kShortDelay);
   histograms_.ExpectTotalCount(kDiscardToReloadTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleState::ACTIVE);
   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(LifecycleState::DISCARDED);
   test_clock_.Advance(kShortDelay);
   histograms_.ExpectTotalCount(kInactiveToReloadTimeHistogram, 0);
 
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleState::ACTIVE);
   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(LifecycleState::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(LifecycleState::DISCARDED);
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   test_clock_.Advance(kShortDelay * 2);
-  lifecycle_unit_->SetState(mojom::LifecycleState::kRunning);
+  lifecycle_unit_->SetState(LifecycleState::ACTIVE);
   histograms_.ExpectTotalCount(kReloadToCloseTimeHistogram, 0);
 
   test_clock_.Advance(kShortDelay * 4);

chrome/browser/resource_coordinator/lifecycle_state.h

+// 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.
+
+#ifndef CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_STATE_H_
+#define CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_STATE_H_
+
+namespace resource_coordinator {
+
+enum class LifecycleState {
+  // The LifecycleUnit is alive and active.
+  ACTIVE,
+  // The LifecycleUnit is frozen.
+  FROZEN,
+  // The LifecycleUnit is discarded, and is consuming no system resources.
+  DISCARDED,
+};
+
+}  // namespace resource_coordinator
+
+#endif  // CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_STATE_H_

chrome/browser/resource_coordinator/lifecycle_unit.h

@@ -13,8 +13,8 @@
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "chrome/browser/resource_coordinator/discard_reason.h"
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 #include "content/public/browser/visibility.h"
-#include "services/resource_coordinator/public/mojom/lifecycle.mojom.h"
 
 namespace resource_coordinator {
 
@@ -72,7 +72,7 @@ class LifecycleUnit {
   virtual SortKey GetSortKey() const = 0;
 
   // Returns the current state of this LifecycleUnit.
-  virtual mojom::LifecycleState GetState() const = 0;
+  virtual LifecycleState GetState() const = 0;
 
   // Returns the current visibility of this LifecycleUnit.
   virtual content::Visibility GetVisibility() const = 0;
@@ -81,7 +81,7 @@ class LifecycleUnit {
   virtual base::TimeTicks GetLastVisibilityChangeTime() const = 0;
 
   // Request that the LifecycleUnit be frozen, return true if the request is
-  // successfully sent.
+  // successfuly sent.
   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 {
+LifecycleState LifecycleUnitBase::GetState() const {
   return state_;
 }
 
@@ -34,13 +34,13 @@ void LifecycleUnitBase::RemoveObserver(LifecycleUnitObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void LifecycleUnitBase::SetState(mojom::LifecycleState state) {
+void LifecycleUnitBase::SetState(LifecycleState state) {
   if (state == state_)
     return;
-  mojom::LifecycleState previous_state = state_;
+  LifecycleState last_state = state_;
   state_ = state;
   for (auto& observer : observers_)
-    observer.OnLifecycleUnitStateChanged(this, previous_state);
+    observer.OnLifecycleUnitStateChanged(this, last_state);
 }
 
 void LifecycleUnitBase::OnLifecycleUnitVisibilityChanged(

chrome/browser/resource_coordinator/lifecycle_unit_base.h

@@ -7,6 +7,7 @@
 
 #include "base/macros.h"
 #include "base/observer_list.h"
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 #include "chrome/browser/resource_coordinator/lifecycle_unit.h"
 #include "content/public/browser/visibility.h"
 
@@ -20,14 +21,14 @@ class LifecycleUnitBase : public LifecycleUnit {
 
   // LifecycleUnit:
   int32_t GetID() const override;
-  mojom::LifecycleState GetState() const override;
+  LifecycleState 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(LifecycleState state);
 
   // Notifies observers that the visibility of the LifecycleUnit has changed.
   void OnLifecycleUnitVisibilityChanged(content::Visibility visibility);
@@ -44,7 +45,7 @@ class LifecycleUnitBase : public LifecycleUnit {
   const int32_t id_ = ++next_id_;
 
   // Current state of this LifecycleUnit.
-  mojom::LifecycleState state_ = mojom::LifecycleState::kRunning;
+  LifecycleState state_ = LifecycleState::ACTIVE;
 
   base::TimeTicks last_visibility_change_time_;
 

chrome/browser/resource_coordinator/lifecycle_unit_base_unittest.cc

@@ -21,7 +21,7 @@ class MockLifecycleUnitObserver : public LifecycleUnitObserver {
   MockLifecycleUnitObserver() = default;
 
   MOCK_METHOD2(OnLifecycleUnitStateChanged,
-               void(LifecycleUnit*, mojom::LifecycleState));
+               void(LifecycleUnit*, LifecycleState));
   MOCK_METHOD2(OnLifecycleUnitVisibilityChanged,
                void(LifecycleUnit*, content::Visibility));
   MOCK_METHOD1(OnLifecycleUnitDestroyed, void(LifecycleUnit*));
@@ -88,11 +88,11 @@ TEST(LifecycleUnitBaseTest, SetStateNotifiesObservers) {
   // Observer is notified when the state changes.
   EXPECT_CALL(observer, OnLifecycleUnitStateChanged(&lifecycle_unit,
                                                     lifecycle_unit.GetState()));
-  lifecycle_unit.SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit.SetState(LifecycleState::DISCARDED);
   testing::Mock::VerifyAndClear(&observer);
 
   // Observer isn't notified when the state stays the same.
-  lifecycle_unit.SetState(mojom::LifecycleState::kDiscarded);
+  lifecycle_unit.SetState(LifecycleState::DISCARDED);
 
   lifecycle_unit.RemoveObserver(&observer);
 }

chrome/browser/resource_coordinator/lifecycle_unit_observer.cc

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

chrome/browser/resource_coordinator/lifecycle_unit_observer.h

@@ -5,8 +5,8 @@
 #ifndef CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_UNIT_OBSERVER_H_
 #define CHROME_BROWSER_RESOURCE_COORDINATOR_LIFECYCLE_UNIT_OBSERVER_H_
 
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 #include "content/public/browser/visibility.h"
-#include "services/resource_coordinator/public/mojom/lifecycle.mojom.h"
 
 namespace resource_coordinator {
 
@@ -18,9 +18,8 @@ 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,
+                                           LifecycleState last_state);
 
   // Invoked when the visibility of the observed LifecyleUnit changes.
   virtual void OnLifecycleUnitVisibilityChanged(LifecycleUnit* lifecycle_unit,

chrome/browser/resource_coordinator/tab_lifecycle_unit.cc

@@ -10,6 +10,7 @@
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 #include "chrome/browser/resource_coordinator/tab_lifecycle_observer.h"
 #include "chrome/browser/resource_coordinator/time.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ -23,6 +24,22 @@
 
 namespace resource_coordinator {
 
+namespace {
+
+// Translates a mojom::LifecycleState to resource_coordinator::LifecycleState.
+LifecycleState GetLifecycleStateFromMojoState(mojom::LifecycleState state) {
+  switch (state) {
+    case mojom::LifecycleState::kDiscarded:
+      return LifecycleState::DISCARDED;
+    case mojom::LifecycleState::kFrozen:
+      return LifecycleState::FROZEN;
+    case mojom::LifecycleState::kRunning:
+      return LifecycleState::ACTIVE;
+  }
+}
+
+}  // namespace
+
 TabLifecycleUnitSource::TabLifecycleUnit::TabLifecycleUnit(
     base::ObserverList<TabLifecycleObserver>* observers,
     content::WebContents* web_contents,
@@ -56,8 +73,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() == LifecycleState::DISCARDED) {
+    SetState(LifecycleState::ACTIVE);
     // 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
@@ -79,7 +96,7 @@ void TabLifecycleUnitSource::TabLifecycleUnit::SetRecentlyAudible(
 void TabLifecycleUnitSource::TabLifecycleUnit::UpdateLifecycleState(
     mojom::LifecycleState state) {
   DCHECK_NE(mojom::LifecycleState::kDiscarded, state);
-  SetState(state);
+  SetState(GetLifecycleStateFromMojoState(state));
 }
 
 TabLifecycleUnitExternal*
@@ -113,9 +130,11 @@ 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.
+  if (GetState() == LifecycleState::DISCARDED ||
+      GetState() == LifecycleState::FROZEN) {
     return false;
+  }
 
   GetWebContents()->FreezePage();
   return true;
@@ -208,7 +227,7 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::CanDiscard(
 
 bool TabLifecycleUnitSource::TabLifecycleUnit::Discard(
     DiscardReason discard_reason) {
-  if (!tab_strip_model_ || IsDiscarded())
+  if (!tab_strip_model_ || GetState() == LifecycleState::DISCARDED)
     return false;
 
   UMA_HISTOGRAM_BOOLEAN(
@@ -278,7 +297,7 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::Discard(
   // RenderFrameProxyHosts.
   old_contents_deleter.reset();
 
-  SetState(mojom::LifecycleState::kDiscarded);
+  SetState(LifecycleState::DISCARDED);
   ++discard_count_;
   OnDiscardedStateChange();
 
@@ -334,11 +353,11 @@ bool TabLifecycleUnitSource::TabLifecycleUnit::FreezeTab() {
 }
 
 bool TabLifecycleUnitSource::TabLifecycleUnit::IsDiscarded() const {
-  return GetState() == mojom::LifecycleState::kDiscarded;
+  return GetState() == LifecycleState::DISCARDED;
 }
 
 bool TabLifecycleUnitSource::TabLifecycleUnit::IsFrozen() const {
-  return GetState() == mojom::LifecycleState::kFrozen;
+  return GetState() == LifecycleState::FROZEN;
 }
 
 int TabLifecycleUnitSource::TabLifecycleUnit::GetDiscardCount() const {
@@ -357,7 +376,7 @@ TabLifecycleUnitSource::TabLifecycleUnit::GetRenderProcessHost() const {
 
 void TabLifecycleUnitSource::TabLifecycleUnit::DidStartLoading() {
   if (IsDiscarded()) {
-    SetState(mojom::LifecycleState::kRunning);
+    SetState(LifecycleState::ACTIVE);
     OnDiscardedStateChange();
   }
 }

chrome/browser/resource_coordinator/tab_lifecycle_unit.h

@@ -90,6 +90,7 @@ class TabLifecycleUnitSource::TabLifecycleUnit
   int GetDiscardCount() const override;
 
  protected:
+  FRIEND_TEST_ALL_PREFIXES(TabLifecycleUnitTest, CannotFreezeAFrozenTab);
   // TabLifecycleUnitSource needs to update the state when a external lifecycle
   // state change is observed.
   friend class TabLifecycleUnitSource;

chrome/browser/resource_coordinator/tab_lifecycle_unit_source.cc

@@ -220,8 +220,8 @@ void TabLifecycleUnitSource::OnLifecycleStateChanged(
     mojom::LifecycleState state) {
   TabLifecycleUnit* lifecycle_unit = GetTabLifecycleUnit(web_contents);
 
-  // Some WebContents aren't attached to a tab, so there is no corresponding
-  // TabLifecycleUnit.
+  // The lifecycle state is currently only maintained for tabs, and some
+  // WebContents aren't attached to a tab.
   if (lifecycle_unit)
     lifecycle_unit->UpdateLifecycleState(state);
 }

chrome/browser/resource_coordinator/tab_lifecycle_unit_source_unittest.cc

@@ -70,7 +70,7 @@ class MockLifecycleUnitObserver : public LifecycleUnitObserver {
   MockLifecycleUnitObserver() = default;
 
   MOCK_METHOD2(OnLifecycleUnitStateChanged,
-               void(LifecycleUnit* lifecycle_unit, mojom::LifecycleState));
+               void(LifecycleUnit* lifecycle_unit, LifecycleState));
   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(LifecycleState::ACTIVE, 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(LifecycleState::DISCARDED, first_lifecycle_unit->GetState());
 
   // Expect a notification when the tab is closed.
   CloseTabsAndExpectNotifications(&other_tab_strip_model,
@@ -410,15 +409,13 @@ TEST_F(TabLifecycleUnitSourceTest, Discard) {
   initial_web_contents->SetLastActiveTime(kDummyLastActiveTime);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, 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,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::DISCARDED, background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -437,13 +434,11 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndActivate) {
       tab_strip_model_->GetWebContentsAt(0);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, 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_EQ(LifecycleState::DISCARDED, background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -452,8 +447,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,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
 }
@@ -467,13 +461,11 @@ TEST_F(TabLifecycleUnitSourceTest, DiscardAndExplicitlyReload) {
       tab_strip_model_->GetWebContentsAt(0);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, 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_EQ(LifecycleState::DISCARDED, background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -483,8 +475,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,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
 }
@@ -501,13 +492,11 @@ TEST_F(TabLifecycleUnitSourceTest, CanOnlyDiscardOnce) {
   EXPECT_FOR_ALL_DISCARD_REASONS(background_lifecycle_unit, CanDiscard, true);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, 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_EQ(LifecycleState::DISCARDED, background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -517,8 +506,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,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
 
@@ -547,13 +535,11 @@ TEST_F(TabLifecycleUnitSourceTest, CannotFreezeADiscardedTab) {
   EXPECT_FOR_ALL_DISCARD_REASONS(background_lifecycle_unit, CanDiscard, true);
 
   // Discard the tab.
-  EXPECT_EQ(mojom::LifecycleState::kRunning,
-            background_lifecycle_unit->GetState());
+  EXPECT_EQ(LifecycleState::ACTIVE, 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_EQ(LifecycleState::DISCARDED, background_lifecycle_unit->GetState());
   EXPECT_NE(initial_web_contents, tab_strip_model_->GetWebContentsAt(0));
   EXPECT_FALSE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
@@ -565,8 +551,7 @@ TEST_F(TabLifecycleUnitSourceTest, CannotFreezeADiscardedTab) {
   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_EQ(LifecycleState::ACTIVE, background_lifecycle_unit->GetState());
   EXPECT_TRUE(
       tab_strip_model_->GetWebContentsAt(0)->GetController().GetPendingEntry());
 

chrome/browser/resource_coordinator/tab_lifecycle_unit_unittest.cc

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

chrome/browser/resource_coordinator/tab_manager.cc

@@ -118,9 +118,10 @@ 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)
+  for (auto* lifecycle_unit : lifecycle_unit_set) {
+    if (lifecycle_unit->GetState() != LifecycleState::DISCARDED)
       num_loaded_lifecycle_units++;
+  }
   return num_loaded_lifecycle_units;
 }
 
@@ -1026,12 +1027,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)
+void TabManager::OnLifecycleUnitStateChanged(LifecycleUnit* lifecycle_unit,
+                                             LifecycleState last_state) {
+  if (lifecycle_unit->GetState() == LifecycleState::DISCARDED)
     num_loaded_lifecycle_units_--;
-  else if (previous_state == mojom::LifecycleState::kDiscarded)
+  else if (last_state == LifecycleState::DISCARDED)
     num_loaded_lifecycle_units_++;
 
   DCHECK_EQ(num_loaded_lifecycle_units_,
@@ -1047,7 +1047,7 @@ void TabManager::OnLifecycleUnitVisibilityChanged(
 }
 
 void TabManager::OnLifecycleUnitDestroyed(LifecycleUnit* lifecycle_unit) {
-  if (lifecycle_unit->GetState() != mojom::LifecycleState::kDiscarded)
+  if (lifecycle_unit->GetState() != LifecycleState::DISCARDED)
     num_loaded_lifecycle_units_--;
   lifecycle_units_.erase(lifecycle_unit);
 
@@ -1059,7 +1059,7 @@ 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() != LifecycleState::DISCARDED)
     num_loaded_lifecycle_units_++;
 
   // Add an observer to be notified of destruction.

chrome/browser/resource_coordinator/tab_manager.h

@@ -21,6 +21,7 @@
 #include "base/timer/timer.h"
 #include "build/build_config.h"
 #include "chrome/browser/resource_coordinator/discard_reason.h"
+#include "chrome/browser/resource_coordinator/lifecycle_state.h"
 #include "chrome/browser/resource_coordinator/lifecycle_unit.h"
 #include "chrome/browser/resource_coordinator/lifecycle_unit_observer.h"
 #include "chrome/browser/resource_coordinator/lifecycle_unit_source_observer.h"
@@ -427,9 +428,8 @@ 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,
+                                   LifecycleState last_state) override;
 
   // LifecycleUnitSourceObserver:
   void OnLifecycleUnitCreated(LifecycleUnit* lifecycle_unit) override;