[ TabRestore ] Move restore types out of TabRestoreService

Moves the tab restore structs Entry, Tab, Group, and Window out
of the TabRestoreService and into its own file.

The goal of this CL is to decouple LiveTabContext from
TabRestoreService, which includes LiveTabContext. Doing this will allow
us to pass the Tab, Group, and Window types as parameters to functions
such as LiveTabContext::AddRestoredTab instead of passing all the fields
of the objects individually.

Change-Id: I2f30bb25f934806112333d67ed3586dade09fe46
Bug: 334170377
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5449978
Commit-Queue: Darryl James <dljames@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Gauthier Ambard <gambard@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1288110}

chrome/browser/android/recently_closed_tabs_bridge.cc

@@ -64,7 +64,7 @@ void PrepareTabs(
     std::vector<ScopedJavaLocalRef<jobject>>& urls,
     std::vector<std::optional<base::Token>>& group_ids) {
   while (it.CurrentEntry() == current_entry) {
-    const sessions::TabRestoreService::Tab& tab = *it;
+    const sessions::tab_restore::Tab& tab = *it;
     const sessions::SerializedNavigationEntry& current_navigation =
         tab.navigations.at(tab.current_navigation_index);
     ids.push_back(tab.id.id());
@@ -82,7 +82,7 @@ void PrepareTabs(
 // Add a tab entry to the main entries list.
 void JNI_RecentlyClosedBridge_AddTabToEntries(
     JNIEnv* env,
-    const sessions::TabRestoreService::Tab& tab,
+    const sessions::tab_restore::Tab& tab,
     const JavaRef<jobject>& jentries) {
   const sessions::SerializedNavigationEntry& current_navigation =
       tab.navigations.at(tab.current_navigation_index);
@@ -98,7 +98,7 @@ void JNI_RecentlyClosedBridge_AddGroupToEntries(
     JNIEnv* env,
     TabIterator& it,
     const sessions::TabRestoreService::Entries::const_iterator& current_entry,
-    const sessions::TabRestoreService::Group& group,
+    const sessions::tab_restore::Group& group,
     const JavaRef<jobject>& jentries) {
   std::vector<int32_t> ids;
   std::vector<int64_t> timestamps;
@@ -124,7 +124,7 @@ void JNI_RecentlyClosedBridge_AddBulkEventToEntries(
     JNIEnv* env,
     TabIterator& it,
     const sessions::TabRestoreService::Entries::const_iterator& current_entry,
-    const sessions::TabRestoreService::Window& window,
+    const sessions::tab_restore::Window& window,
     const JavaRef<jobject>& jentries) {
   std::vector<int> ids;
   std::vector<int64_t> timestamps;
@@ -175,16 +175,16 @@ void JNI_RecentlyClosedBridge_AddEntriesToList(
     }
 
     auto entry = it.CurrentEntry();
-    if ((*entry)->type == sessions::TabRestoreService::GROUP) {
+    if ((*entry)->type == sessions::tab_restore::Type::GROUP) {
       const auto& group =
-          static_cast<const sessions::TabRestoreService::Group&>(**entry);
+          static_cast<const sessions::tab_restore::Group&>(**entry);
       JNI_RecentlyClosedBridge_AddGroupToEntries(env, it, entry, group,
                                                  jentries);
       continue;
     }
-    if ((*entry)->type == sessions::TabRestoreService::WINDOW) {
+    if ((*entry)->type == sessions::tab_restore::Type::WINDOW) {
       const auto& window =
-          static_cast<const sessions::TabRestoreService::Window&>(**entry);
+          static_cast<const sessions::tab_restore::Window&>(**entry);
       JNI_RecentlyClosedBridge_AddBulkEventToEntries(env, it, entry, window,
                                                      jentries);
       continue;
@@ -216,7 +216,7 @@ TabIterator TabIterator::end(
 }
 
 bool TabIterator::IsCurrentEntryTab() const {
-  return (*current_entry_)->type == sessions::TabRestoreService::TAB;
+  return (*current_entry_)->type == sessions::tab_restore::Type::TAB;
 }
 
 sessions::TabRestoreService::Entries::const_iterator TabIterator::CurrentEntry()
@@ -266,15 +266,15 @@ bool TabIterator::operator!=(TabIterator other) const {
   return !(*this == other);
 }
 
-const sessions::TabRestoreService::Tab& TabIterator::operator*() const {
-  return current_tab_ ? ***current_tab_
-                      : static_cast<const sessions::TabRestoreService::Tab&>(
-                            **current_entry_);
+const sessions::tab_restore::Tab& TabIterator::operator*() const {
+  return current_tab_
+             ? ***current_tab_
+             : static_cast<const sessions::tab_restore::Tab&>(**current_entry_);
 }
 
-const sessions::TabRestoreService::Tab* TabIterator::operator->() const {
+const sessions::tab_restore::Tab* TabIterator::operator->() const {
   return current_tab_ ? (*current_tab_)->get()
-                      : static_cast<const sessions::TabRestoreService::Tab*>(
+                      : static_cast<const sessions::tab_restore::Tab*>(
                             current_entry_->get());
 }
 
@@ -283,13 +283,13 @@ void TabIterator::SetupInnerTabList() {
     return;
   }
 
-  if ((*current_entry_)->type == sessions::TabRestoreService::GROUP) {
-    tabs_ = &static_cast<const sessions::TabRestoreService::Group*>(
-                 current_entry_->get())
-                 ->tabs;
+  if ((*current_entry_)->type == sessions::tab_restore::Type::GROUP) {
+    tabs_ =
+        &static_cast<const sessions::tab_restore::Group*>(current_entry_->get())
+             ->tabs;
   }
-  if ((*current_entry_)->type == sessions::TabRestoreService::WINDOW) {
-    tabs_ = &static_cast<const sessions::TabRestoreService::Window*>(
+  if ((*current_entry_)->type == sessions::tab_restore::Type::WINDOW) {
+    tabs_ = &static_cast<const sessions::tab_restore::Window*>(
                  current_entry_->get())
                  ->tabs;
   }

chrome/browser/android/recently_closed_tabs_bridge.h

@@ -27,7 +27,7 @@ class TabIterator {
  public:
   using iterator_category = std::forward_iterator_tag;
   using difference_type = size_t;
-  using value_type = sessions::TabRestoreService::Tab;
+  using value_type = sessions::tab_restore::Tab;
   using pointer = value_type*;
   using reference = value_type&;
 
@@ -40,7 +40,7 @@ class TabIterator {
 
   static TabIterator end(const sessions::TabRestoreService::Entries& entries);
 
-  // Whether the current entry is a sessions::TabRestoreService::Tab.
+  // Whether the current entry is a sessions::tab_restore::Tab.
   bool IsCurrentEntryTab() const;
 
   // Gets an iterator to the current entry being traversed.
@@ -50,18 +50,18 @@ class TabIterator {
   TabIterator operator++(int);
   bool operator==(TabIterator other) const;
   bool operator!=(TabIterator other) const;
-  const sessions::TabRestoreService::Tab& operator*() const;
-  const sessions::TabRestoreService::Tab* operator->() const;
+  const sessions::tab_restore::Tab& operator*() const;
+  const sessions::tab_restore::Tab* operator->() const;
 
  private:
   void SetupInnerTabList();
 
   const raw_ref<const sessions::TabRestoreService::Entries> entries_;
   sessions::TabRestoreService::Entries::const_iterator current_entry_;
-  raw_ptr<const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>>
+  raw_ptr<const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>>
       tabs_ = nullptr;
-  std::optional<std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>::
-                    const_reverse_iterator>
+  std::optional<std::vector<
+      std::unique_ptr<sessions::tab_restore::Tab>>::const_reverse_iterator>
       current_tab_ = std::nullopt;
 };
 

chrome/browser/android/recently_closed_tabs_bridge_unittest.cc

@@ -14,8 +14,8 @@ namespace {
 
 // Create a new tab entry with `tabstrip_index` of `tab_counter` and increment
 // `tab_counter`.
-std::unique_ptr<sessions::TabRestoreService::Tab> MakeTab(int* tab_counter) {
-  auto tab = std::make_unique<sessions::TabRestoreService::Tab>();
+std::unique_ptr<sessions::tab_restore::Tab> MakeTab(int* tab_counter) {
+  auto tab = std::make_unique<sessions::tab_restore::Tab>();
   tab->tabstrip_index = (*tab_counter)++;
   return tab;
 }
@@ -30,9 +30,9 @@ void AddGroupWithTabs(sessions::TabRestoreService::Entries& entries,
                       const std::u16string& title,
                       int tab_count,
                       int* tab_counter) {
-  entries.push_back(std::make_unique<sessions::TabRestoreService::Group>());
+  entries.push_back(std::make_unique<sessions::tab_restore::Group>());
   auto* group =
-      static_cast<sessions::TabRestoreService::Group*>(entries.back().get());
+      static_cast<sessions::tab_restore::Group*>(entries.back().get());
   group->visual_data = tab_groups::TabGroupVisualData(title, 0);
   for (int i = 0; i < tab_count; ++i) {
     group->tabs.push_back(MakeTab(tab_counter));
@@ -44,9 +44,9 @@ void AddWindowWithTabs(sessions::TabRestoreService::Entries& entries,
                        const std::string& user_title,
                        int tab_count,
                        int* tab_counter) {
-  entries.push_back(std::make_unique<sessions::TabRestoreService::Window>());
+  entries.push_back(std::make_unique<sessions::tab_restore::Window>());
   auto* window =
-      static_cast<sessions::TabRestoreService::Window*>(entries.back().get());
+      static_cast<sessions::tab_restore::Window*>(entries.back().get());
   window->user_title = user_title;
   for (int i = 0; i < tab_count; ++i) {
     window->tabs.push_back(MakeTab(tab_counter));
@@ -94,9 +94,10 @@ TEST(RecentlyClosedTabsBridge_TabIterator, AllEntryTypes) {
   ASSERT_NE(it, TabIterator::end(entries));
   EXPECT_FALSE(it.IsCurrentEntryTab());
   auto entry = it.CurrentEntry();
-  EXPECT_EQ(sessions::TabRestoreService::GROUP, (*entry)->type);
-  EXPECT_EQ(u"foo", static_cast<sessions::TabRestoreService::Group&>(**entry)
-                        .visual_data.title());
+  EXPECT_EQ(sessions::tab_restore::Type::GROUP, (*entry)->type);
+  EXPECT_EQ(
+      u"foo",
+      static_cast<sessions::tab_restore::Group&>(**entry).visual_data.title());
   EXPECT_EQ(1, it->tabstrip_index);
   ++it;
   ASSERT_NE(it, TabIterator::end(entries));
@@ -115,10 +116,9 @@ TEST(RecentlyClosedTabsBridge_TabIterator, AllEntryTypes) {
   ASSERT_NE(it, TabIterator::end(entries));
   EXPECT_FALSE(it.IsCurrentEntryTab());
   entry = it.CurrentEntry();
-  EXPECT_EQ(sessions::TabRestoreService::WINDOW, (*entry)->type);
-  EXPECT_EQ(
-      "bar",
-      static_cast<sessions::TabRestoreService::Window&>(**entry).user_title);
+  EXPECT_EQ(sessions::tab_restore::Type::WINDOW, (*entry)->type);
+  EXPECT_EQ("bar",
+            static_cast<sessions::tab_restore::Window&>(**entry).user_title);
   EXPECT_EQ(5, it->tabstrip_index);
   ++it;
   ASSERT_NE(it, TabIterator::end(entries));

chrome/browser/app_controller_mac.h

@@ -222,7 +222,7 @@ class TabRestorer : public sessions::TabRestoreServiceObserver {
   static void RestoreMostRecent(Profile* profile);
 
   // Restore a specific tab in |profile|, e.g. for a History menu item.
-  // |session_id| can be a |TabRestoreService::Entry::id|, or a
+  // |session_id| can be a |tab_restore::Entry::id|, or a
   // |TabRestoreEntryService::Entry::original_id|.
   static void RestoreByID(Profile* profile, SessionID session_id);
 

chrome/browser/browsing_data/navigation_entry_remover_browsertest.cc

@@ -305,7 +305,7 @@ IN_PROC_BROWSER_TEST_F(NavigationEntryRemoverTest, RecentTabDeletion) {
       DeletionInfo::ForUrls({history::URLResult(url_c_, base::Time())}, {}));
   content::RunAllTasksUntilIdle();
   EXPECT_EQ(1U, tab_service->entries().size());
-  auto* tab = static_cast<sessions::TabRestoreService::Tab*>(
+  auto* tab = static_cast<sessions::tab_restore::Tab*>(
       tab_service->entries().front().get());
   EXPECT_EQ(url_d_, tab->navigations.front().virtual_url());
   EXPECT_TRUE(tab_service->IsLoaded());
@@ -331,9 +331,9 @@ IN_PROC_BROWSER_TEST_F(NavigationEntryRemoverTest,
   sessions::TabRestoreService* tab_service =
       TabRestoreServiceFactory::GetForProfile(profile());
   EXPECT_EQ(1U, tab_service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW,
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW,
             tab_service->entries().front()->type);
-  auto* window = static_cast<sessions::TabRestoreService::Window*>(
+  auto* window = static_cast<sessions::tab_restore::Window*>(
       tab_service->entries().front().get());
   EXPECT_EQ(3U, window->tabs.size());
   ExpectDeleteLastSessionCalled(0);
@@ -346,9 +346,9 @@ IN_PROC_BROWSER_TEST_F(NavigationEntryRemoverTest,
                             {}));
   content::RunAllTasksUntilIdle();
   EXPECT_EQ(1U, tab_service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW,
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW,
             tab_service->entries().front()->type);
-  window = static_cast<sessions::TabRestoreService::Window*>(
+  window = static_cast<sessions::tab_restore::Window*>(
       tab_service->entries().front().get());
   EXPECT_EQ(2U, window->tabs.size());
   EXPECT_EQ(2U, window->tabs.size());
@@ -364,9 +364,9 @@ IN_PROC_BROWSER_TEST_F(NavigationEntryRemoverTest,
       profile(),
       DeletionInfo::ForUrls({history::URLResult(url_a_, base::Time())}, {}));
   EXPECT_EQ(1U, tab_service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::TAB,
+  ASSERT_EQ(sessions::tab_restore::Type::TAB,
             tab_service->entries().front()->type);
-  auto* tab = static_cast<sessions::TabRestoreService::Tab*>(
+  auto* tab = static_cast<sessions::tab_restore::Tab*>(
       tab_service->entries().front().get());
   EXPECT_EQ(url_c_, tab->navigations.front().virtual_url());
   EXPECT_EQ(0, tab->tabstrip_index);

chrome/browser/extensions/api/sessions/sessions_api.cc

@@ -36,6 +36,7 @@
 #include "chrome/browser/ui/browser_live_tab_context.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "components/sessions/content/content_live_tab.h"
+#include "components/sessions/core/tab_restore_service.h"
 #include "components/sync_sessions/open_tabs_ui_delegate.h"
 #include "components/sync_sessions/session_sync_service.h"
 #include "components/sync_sessions/synced_session.h"
@@ -147,14 +148,14 @@ api::sessions::Session CreateSessionModelHelper(
   return session_struct;
 }
 
-bool is_window_entry(const sessions::TabRestoreService::Entry& entry) {
-  return entry.type == sessions::TabRestoreService::WINDOW;
+bool is_window_entry(const sessions::tab_restore::Entry& entry) {
+  return entry.type == sessions::tab_restore::Type::WINDOW;
 }
 
 }  // namespace
 
 api::tabs::Tab SessionsGetRecentlyClosedFunction::CreateTabModel(
-    const sessions::TabRestoreService::Tab& tab,
+    const sessions::tab_restore::Tab& tab,
     bool active) {
   return CreateTabModelHelper(tab.navigations[tab.current_navigation_index],
                               base::NumberToString(tab.id.id()),
@@ -163,7 +164,7 @@ api::tabs::Tab SessionsGetRecentlyClosedFunction::CreateTabModel(
 }
 
 api::windows::Window SessionsGetRecentlyClosedFunction::CreateWindowModel(
-    const sessions::TabRestoreService::Window& window) {
+    const sessions::tab_restore::Window& window) {
   DCHECK(!window.tabs.empty());
 
   std::vector<api::tabs::Tab> tabs;
@@ -178,7 +179,7 @@ api::windows::Window SessionsGetRecentlyClosedFunction::CreateWindowModel(
 }
 
 api::tab_groups::TabGroup SessionsGetRecentlyClosedFunction::CreateGroupModel(
-    const sessions::TabRestoreService::Group& group) {
+    const sessions::tab_restore::Group& group) {
   DCHECK(!group.tabs.empty());
 
   return tab_groups_util::CreateTabGroupObject(group.group_id,
@@ -186,22 +187,22 @@ api::tab_groups::TabGroup SessionsGetRecentlyClosedFunction::CreateGroupModel(
 }
 
 api::sessions::Session SessionsGetRecentlyClosedFunction::CreateSessionModel(
-    const sessions::TabRestoreService::Entry& entry) {
+    const sessions::tab_restore::Entry& entry) {
   std::optional<api::tabs::Tab> tab;
   std::optional<api::windows::Window> window;
   std::optional<api::tab_groups::TabGroup> group;
   switch (entry.type) {
-    case sessions::TabRestoreService::TAB:
+    case sessions::tab_restore::Type::TAB:
       tab = CreateTabModel(
-          static_cast<const sessions::TabRestoreService::Tab&>(entry), false);
+          static_cast<const sessions::tab_restore::Tab&>(entry), false);
       break;
-    case sessions::TabRestoreService::WINDOW:
+    case sessions::tab_restore::Type::WINDOW:
       window = CreateWindowModel(
-          static_cast<const sessions::TabRestoreService::Window&>(entry));
+          static_cast<const sessions::tab_restore::Window&>(entry));
       break;
-    case sessions::TabRestoreService::GROUP:
+    case sessions::tab_restore::Type::GROUP:
       group = CreateGroupModel(
-          static_cast<const sessions::TabRestoreService::Group&>(entry));
+          static_cast<const sessions::tab_restore::Group&>(entry));
   }
   return CreateSessionModelHelper(entry.timestamp.ToTimeT(), std::move(tab),
                                   std::move(window), std::move(group));
@@ -237,9 +238,8 @@ ExtensionFunction::ResponseAction SessionsGetRecentlyClosedFunction::Run() {
   for (const auto& entry : tab_restore_service->entries()) {
     // TODO(crbug.com/1192309): Support group entries in the Sessions API,
     // rather than sharding the group out into individual tabs.
-    if (entry->type == sessions::TabRestoreService::GROUP) {
-      auto& group =
-          static_cast<const sessions::TabRestoreService::Group&>(*entry);
+    if (entry->type == sessions::tab_restore::Type::GROUP) {
+      auto& group = static_cast<const sessions::tab_restore::Group&>(*entry);
       for (const auto& tab : group.tabs)
         if (counter++ < max_results)
           result.push_back(CreateSessionModel(*tab));

chrome/browser/extensions/api/sessions/sessions_api.h

@@ -37,14 +37,14 @@ class SessionsGetRecentlyClosedFunction : public ExtensionFunction {
                              SESSIONS_GETRECENTLYCLOSED)
 
  private:
-  api::tabs::Tab CreateTabModel(const sessions::TabRestoreService::Tab& tab,
+  api::tabs::Tab CreateTabModel(const sessions::tab_restore::Tab& tab,
                                 bool active);
   api::windows::Window CreateWindowModel(
-      const sessions::TabRestoreService::Window& window);
+      const sessions::tab_restore::Window& window);
   api::tab_groups::TabGroup CreateGroupModel(
-      const sessions::TabRestoreService::Group& group);
+      const sessions::tab_restore::Group& group);
   api::sessions::Session CreateSessionModel(
-      const sessions::TabRestoreService::Entry& entry);
+      const sessions::tab_restore::Entry& entry);
 };
 
 class SessionsGetDevicesFunction : public ExtensionFunction {

chrome/browser/sessions/session_restore_browsertest.cc

@@ -626,9 +626,9 @@ IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 
   // Expect a window with three tabs.
   ASSERT_EQ(1U, service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW,
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW,
             service->entries().front()->type);
-  auto* window = static_cast<sessions::TabRestoreService::Window*>(
+  auto* window = static_cast<sessions::tab_restore::Window*>(
       service->entries().front().get());
   EXPECT_EQ(3U, window->tabs.size());
 
@@ -639,7 +639,7 @@ IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
   ui_test_utils::BrowserChangeObserver browser_change_observer(
       nullptr, ui_test_utils::BrowserChangeObserver::ChangeType::kAdded);
   for (const auto& tab_ptr : window->tabs) {
-    const sessions::TabRestoreService::Tab& tab = *tab_ptr;
+    const sessions::tab_restore::Tab& tab = *tab_ptr;
     // If this tab held url2, then restore this single tab.
     if (tab.navigations[0].virtual_url() == url2) {
       timestamp = tab.navigations[0].timestamp();
@@ -659,9 +659,9 @@ IN_PROC_BROWSER_TEST_F(SessionRestoreTest,
 
   // Make sure that the restored tab is removed from the service.
   ASSERT_EQ(1U, service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW,
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW,
             service->entries().front()->type);
-  window = static_cast<sessions::TabRestoreService::Window*>(
+  window = static_cast<sessions::tab_restore::Window*>(
       service->entries().front().get());
   EXPECT_EQ(2U, window->tabs.size());
 
@@ -703,8 +703,8 @@ IN_PROC_BROWSER_TEST_F(SessionRestoreTest, MAYBE_WindowWithOneTab) {
 
   // Expect the window to be converted to a tab by the TRS.
   EXPECT_EQ(1U, service->entries().size());
-  ASSERT_EQ(sessions::TabRestoreService::TAB, service->entries().front()->type);
-  auto* tab = static_cast<const sessions::TabRestoreService::Tab*>(
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, service->entries().front()->type);
+  auto* tab = static_cast<const sessions::tab_restore::Tab*>(
       service->entries().front().get());
 
   // Restore the tab.
@@ -1238,9 +1238,9 @@ IN_PROC_BROWSER_TEST_P(SessionRestoreTabGroupsTest, MAYBE_RecentlyClosedGroup) {
       TabRestoreServiceFactory::GetForProfile(browser()->profile());
   const sessions::TabRestoreService::Entries& entries = service->entries();
   ASSERT_GE(entries.size(), 1u);
-  ASSERT_EQ(entries.front()->type, sessions::TabRestoreService::GROUP);
+  ASSERT_EQ(entries.front()->type, sessions::tab_restore::Type::GROUP);
   const auto* const group_entry =
-      static_cast<sessions::TabRestoreService::Group*>(entries.front().get());
+      static_cast<sessions::tab_restore::Group*>(entries.front().get());
   ASSERT_EQ(group_entry->tabs.size(), 2u);
 
   Browser* new_browser = QuitBrowserAndRestore(browser());
@@ -1251,10 +1251,9 @@ IN_PROC_BROWSER_TEST_P(SessionRestoreTabGroupsTest, MAYBE_RecentlyClosedGroup) {
   const sessions::TabRestoreService::Entries& new_entries =
       new_service->entries();
   ASSERT_GE(new_entries.size(), 1u);
-  ASSERT_EQ(new_entries.front()->type, sessions::TabRestoreService::GROUP);
+  ASSERT_EQ(new_entries.front()->type, sessions::tab_restore::Type::GROUP);
   const auto* const new_group_entry =
-      static_cast<sessions::TabRestoreService::Group*>(
-          new_entries.front().get());
+      static_cast<sessions::tab_restore::Group*>(new_entries.front().get());
   ASSERT_EQ(new_group_entry->tabs.size(), 2u);
 }
 

chrome/browser/sessions/tab_restore_browsertest.cc

@@ -543,10 +543,10 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWindowBounds) {
       TabRestoreServiceFactory::GetForProfile(browser->profile());
   const sessions::TabRestoreService::Entries& entries = service->entries();
   EXPECT_EQ(1u, entries.size());
-  sessions::TabRestoreService::Entry* entry = entries.front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* entry_win =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  sessions::tab_restore::Entry* entry = entries.front().get();
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* entry_win =
+      static_cast<sessions::tab_restore::Window*>(entry);
   EXPECT_EQ(bounds, entry_win->bounds);
   auto& tabs = entry_win->tabs;
   EXPECT_EQ(2u, tabs.size());
@@ -796,10 +796,10 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreTabFromClosedWindowByID) {
       TabRestoreServiceFactory::GetForProfile(browser->profile());
   const sessions::TabRestoreService::Entries& entries = service->entries();
   EXPECT_EQ(1u, entries.size());
-  sessions::TabRestoreService::Entry* entry = entries.front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* entry_win =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  sessions::tab_restore::Entry* entry = entries.front().get();
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* entry_win =
+      static_cast<sessions::tab_restore::Window*>(entry);
   auto& tabs = entry_win->tabs;
   EXPECT_EQ(3u, tabs.size());
   EXPECT_EQ(url::kAboutBlankURL, tabs[0]->navigations.front().virtual_url());
@@ -1198,7 +1198,7 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, PRE_GetRestoreTabType) {
 
   // We now should see a Tab as the restore type.
   ASSERT_EQ(1u, service->entries().size());
-  EXPECT_EQ(sessions::TabRestoreService::TAB, service->entries().front()->type);
+  EXPECT_EQ(sessions::tab_restore::Type::TAB, service->entries().front()->type);
 }
 
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, GetRestoreTabType) {
@@ -1214,7 +1214,7 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, GetRestoreTabType) {
 
   // When we start this time we should get a Tab.
   ASSERT_GE(service->entries().size(), 1u);
-  EXPECT_EQ(sessions::TabRestoreService::TAB, service->entries().front()->type);
+  EXPECT_EQ(sessions::tab_restore::Type::TAB, service->entries().front()->type);
 }
 
 IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoreWindowWithName) {
@@ -1846,7 +1846,7 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, RestoredWindowHasNewGroupIds) {
   // We should have a restore entry for the window.
   const sessions::TabRestoreService::Entries& entries = service->entries();
   ASSERT_GE(entries.size(), 1u);
-  ASSERT_EQ(entries.front()->type, sessions::TabRestoreService::WINDOW);
+  ASSERT_EQ(entries.front()->type, sessions::tab_restore::Type::WINDOW);
 
   // Restore the window.
   std::vector<sessions::LiveTab*> restored_window_tabs =
@@ -1894,10 +1894,10 @@ IN_PROC_BROWSER_TEST_F(TabRestoreTest, WindowTabGroupsMatchesWindowTabs) {
   // We should have a restore entry for the window.
   const sessions::TabRestoreService::Entries& entries = service->entries();
   ASSERT_GE(entries.size(), 1u);
-  ASSERT_EQ(entries.front()->type, sessions::TabRestoreService::WINDOW);
+  ASSERT_EQ(entries.front()->type, sessions::tab_restore::Type::WINDOW);
 
   const auto* const window_entry =
-      static_cast<sessions::TabRestoreService::Window*>(entries.front().get());
+      static_cast<sessions::tab_restore::Window*>(entries.front().get());
   ASSERT_NE(window_entry->tab_groups.find(single_entry_group),
             window_entry->tab_groups.end());
   ASSERT_NE(window_entry->tab_groups.find(double_entry_group),

chrome/browser/sessions/tab_restore_service_browsertest.cc

@@ -15,7 +15,7 @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/browser_test.h"
 
-using Window = sessions::TabRestoreService::Window;
+using Window = sessions::tab_restore::Window;
 
 class TabRestoreServiceImplBrowserTest : public InProcessBrowserTest {
  public:
@@ -39,11 +39,11 @@ IN_PROC_BROWSER_TEST_F(TabRestoreServiceImplBrowserTest, RestoreApp) {
 
   // One entry should be created.
   ASSERT_EQ(1U, trs->entries().size());
-  const sessions::TabRestoreService::Entry* restored_entry =
+  const sessions::tab_restore::Entry* restored_entry =
       trs->entries().front().get();
 
   // It should be a window with an app.
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, restored_entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, restored_entry->type);
   const Window* restored_window = static_cast<const Window*>(restored_entry);
   EXPECT_EQ(app_name, restored_window->app_name);
 }
@@ -67,16 +67,15 @@ IN_PROC_BROWSER_TEST_F(TabRestoreServiceImplBrowserTest,
   ASSERT_TRUE(ui_test_utils::NavigateToURL(app_browser, app_url));
   chrome::CloseTab(app_browser);
   ASSERT_EQ(1U, trs->entries().size());
-  const sessions::TabRestoreService::Entry* tab_entry =
-      trs->entries().front().get();
-  EXPECT_EQ(sessions::TabRestoreService::TAB, tab_entry->type);
+  const sessions::tab_restore::Entry* tab_entry = trs->entries().front().get();
+  EXPECT_EQ(sessions::tab_restore::Type::TAB, tab_entry->type);
 
   // Close last tab, WINDOW entry should be created.
   chrome::CloseTab(app_browser);
   EXPECT_EQ(2U, trs->entries().size());
-  const sessions::TabRestoreService::Entry* window_entry =
+  const sessions::tab_restore::Entry* window_entry =
       trs->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, window_entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, window_entry->type);
   const Window* restored_window = static_cast<const Window*>(window_entry);
   EXPECT_EQ(app_browser->app_name(), restored_window->app_name);
   EXPECT_EQ(1U, restored_window->tabs.size());

chrome/browser/sessions/tab_restore_service_unittest.cc

@@ -53,9 +53,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/common/user_agent/user_agent_metadata.h"
 
-typedef sessions::TabRestoreService::Entry Entry;
-typedef sessions::TabRestoreService::Tab Tab;
-typedef sessions::TabRestoreService::Window Window;
+typedef sessions::tab_restore::Entry Entry;
+typedef sessions::tab_restore::Tab Tab;
+typedef sessions::tab_restore::Window Window;
 typedef std::map<std::string, std::string> ExtraData;
 
 using content::NavigationEntry;
@@ -78,8 +78,9 @@ class MockLiveTab : public sessions::LiveTab {
   MOCK_METHOD1(GetEntryAtIndex, sessions::SerializedNavigationEntry(int index));
   MOCK_METHOD0(GetPendingEntry, sessions::SerializedNavigationEntry());
   MOCK_METHOD0(GetEntryCount, int());
-  MOCK_METHOD0(GetPlatformSpecificTabData,
-               std::unique_ptr<sessions::PlatformSpecificTabData>());
+  MOCK_METHOD0(
+      GetPlatformSpecificTabData,
+      std::unique_ptr<sessions::tab_restore::PlatformSpecificTabData>());
   MOCK_METHOD0(GetUserAgentOverride, sessions::SerializedUserAgentOverride());
 };
 
@@ -127,7 +128,7 @@ class MockLiveTabContext : public sessions::LiveTabContext {
                (const tab_groups::TabGroupVisualData&),
                bool,
                bool,
-               const sessions::PlatformSpecificTabData*,
+               const sessions::tab_restore::PlatformSpecificTabData*,
                (const sessions::SerializedUserAgentOverride&),
                (const std::map<std::string, std::string>&),
                (const SessionID*)),
@@ -139,7 +140,7 @@ class MockLiveTabContext : public sessions::LiveTabContext {
                std::optional<tab_groups::TabGroupId>,
                int,
                (const std::string&),
-               (const sessions::PlatformSpecificTabData*),
+               (const sessions::tab_restore::PlatformSpecificTabData*),
                (const sessions::SerializedUserAgentOverride&),
                (const std::map<std::string, std::string>&)),
               (override));
@@ -179,7 +180,7 @@ class MockTabRestoreServiceClient : public sessions::TabRestoreServiceClient {
 
 // Create subclass that overrides TimeNow so that we can control the time used
 // for closed tabs and windows.
-class TabRestoreTimeFactory : public sessions::TabRestoreService::TimeFactory {
+class TabRestoreTimeFactory : public sessions::tab_restore::TimeFactory {
  public:
   TabRestoreTimeFactory() : time_(base::Time::Now()) {}
 
@@ -380,7 +381,7 @@ TEST_F(TabRestoreServiceImplTest, Basic) {
 
   // Make sure the entry matches.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   EXPECT_TRUE(tab->extension_app_id.empty());
@@ -408,7 +409,7 @@ TEST_F(TabRestoreServiceImplTest, Basic) {
 
   // Make sure the entry matches.
   entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -456,7 +457,7 @@ TEST_F(TabRestoreServiceImplWithMockClientTest,
   ASSERT_EQ(1U, service_->entries().size());
   // Make sure the entry data matches.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_EQ(1U, tab->navigations.size());
   EXPECT_EQ(url1_, tab->navigations[0].virtual_url());
@@ -501,7 +502,7 @@ TEST_F(TabRestoreServiceImplWithMockClientTest, WindowRestore) {
   auto validate = [&]() {
     ASSERT_EQ(1u, service_->entries().size());
     Entry* entry = service_->entries().front().get();
-    EXPECT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
+    EXPECT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
     Window* window = static_cast<Window*>(entry);
     EXPECT_EQ(sessions::SessionWindow::TYPE_APP_POPUP, window->type);
     EXPECT_EQ(0, window->selected_tab_index);
@@ -541,7 +542,7 @@ TEST_F(TabRestoreServiceImplTest, Restore) {
 
   // And verify the entry.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   EXPECT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -571,7 +572,7 @@ TEST_F(TabRestoreServiceImplTest, RestoreManyNavigations) {
 
   // And verify the entry.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   // Only gMaxPersistNavigationCount + 1 (current navigation) are persisted.
   ASSERT_EQ(7U, tab->navigations.size());
@@ -594,7 +595,7 @@ TEST_F(TabRestoreServiceImplTest, RestorePinnedAndApp) {
   // We have to explicitly mark the tab as pinned as there is no browser for
   // these tests.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   tab->pinned = true;
   const std::string extension_app_id("test");
@@ -608,7 +609,7 @@ TEST_F(TabRestoreServiceImplTest, RestorePinnedAndApp) {
 
   // And verify the entry.
   entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   tab = static_cast<Tab*>(entry);
   EXPECT_TRUE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -629,7 +630,7 @@ TEST_F(TabRestoreServiceImplTest, DontCreateRestoredEntry) {
 
   // Record the tab's id.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   SessionID first_id = entry->id;
 
   // Service record the second tab.
@@ -638,7 +639,7 @@ TEST_F(TabRestoreServiceImplTest, DontCreateRestoredEntry) {
 
   // Record the tab's id.
   entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   SessionID second_id = entry->id;
 
   service_->Shutdown();
@@ -654,7 +655,7 @@ TEST_F(TabRestoreServiceImplTest, DontCreateRestoredEntry) {
 
   // And verify the entry.
   entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   ASSERT_EQ(first_id, entry->original_id);
 }
 
@@ -674,7 +675,7 @@ TEST_F(TabRestoreServiceImplTest, DeleteNavigationEntries) {
   // The entry should still exist but url2_ was removed and indices adjusted.
   ASSERT_EQ(1U, service_->entries().size());
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_EQ(2U, tab->navigations.size());
   EXPECT_EQ(url1_, tab->navigations[0].virtual_url());
@@ -725,7 +726,7 @@ TEST_F(TabRestoreServiceImplTest, DeleteEntriesAndRecreate) {
   // The entry should still exist but url2_ was removed and indices adjusted.
   ASSERT_EQ(1U, service_->entries().size());
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_EQ(2U, tab->navigations.size());
   EXPECT_EQ(url1_, tab->navigations[0].virtual_url());
@@ -761,7 +762,7 @@ TEST_F(TabRestoreServiceImplTest, DontPersistPostData) {
   ASSERT_EQ(1U, service_->entries().size());
 
   const Entry* restored_entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, restored_entry->type);
 
   const Tab* restored_tab = static_cast<const Tab*>(restored_entry);
   // There should be 3 navs.
@@ -804,9 +805,9 @@ TEST_F(TabRestoreServiceImplTest, LoadPreviousSession) {
   // Make sure we get back one entry with one tab whose url is url1.
   ASSERT_EQ(1U, service_->entries().size());
   Entry* entry2 = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry2->type);
-  sessions::TabRestoreService::Window* window =
-      static_cast<sessions::TabRestoreService::Window*>(entry2);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry2->type);
+  sessions::tab_restore::Window* window =
+      static_cast<sessions::tab_restore::Window*>(entry2);
   EXPECT_EQ(sessions::SessionWindow::TYPE_NORMAL, window->type);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->timestamp.ToDeltaSinceWindowsEpoch().InMicroseconds());
@@ -894,7 +895,7 @@ TEST_F(TabRestoreServiceImplTest, WindowShowStateIsSet) {
   // default.
   bool got_window = false;
   for (auto& entry : service_->entries()) {
-    if (entry->type == sessions::TabRestoreService::WINDOW) {
+    if (entry->type == sessions::tab_restore::Type::WINDOW) {
       got_window = true;
       Window* window = static_cast<Window*>(entry.get());
       EXPECT_EQ(window->show_state, ui::SHOW_STATE_DEFAULT);
@@ -920,9 +921,9 @@ TEST_F(TabRestoreServiceImplTest, LoadPreviousSessionAndTabs) {
   ASSERT_EQ(2U, service_->entries().size());
   // The first entry should come from the session service.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* window =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* window =
+      static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_EQ(0, window->timestamp.ToDeltaSinceWindowsEpoch().InMicroseconds());
@@ -935,7 +936,7 @@ TEST_F(TabRestoreServiceImplTest, LoadPreviousSessionAndTabs) {
 
   // Then the closed tab.
   entry = (++service_->entries().begin())->get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -977,9 +978,9 @@ TEST_F(TabRestoreServiceImplTest, LoadWindowBoundsAndWorkspace) {
 
   // The first entry should come from the session service.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* window =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* window =
+      static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(kBounds, window->bounds);
   ASSERT_EQ(kShowState, window->show_state);
   ASSERT_EQ(kWorkspace, window->workspace);
@@ -992,7 +993,7 @@ TEST_F(TabRestoreServiceImplTest, LoadWindowBoundsAndWorkspace) {
 
   // Then the closed tab.
   entry = (++service_->entries().begin())->get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -1020,9 +1021,9 @@ TEST_F(TabRestoreServiceImplTest, LoadPreviousSessionAndTabsPinned) {
   ASSERT_EQ(2U, service_->entries().size());
   // The first entry should come from the session service.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* window =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* window =
+      static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_TRUE(window->tabs[0]->pinned);
@@ -1032,7 +1033,7 @@ TEST_F(TabRestoreServiceImplTest, LoadPreviousSessionAndTabsPinned) {
 
   // Then the closed tab.
   entry = (++service_->entries().begin())->get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
   Tab* tab = static_cast<Tab*>(entry);
   ASSERT_FALSE(tab->pinned);
   ASSERT_EQ(3U, tab->navigations.size());
@@ -1065,9 +1066,9 @@ TEST_F(TabRestoreServiceImplTest, ManyWindowsInSessionService) {
 
   // The first entry should come from the session service.
   Entry* entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  sessions::TabRestoreService::Window* window =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  sessions::tab_restore::Window* window =
+      static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   EXPECT_EQ(0, window->selected_tab_index);
   EXPECT_EQ(0, window->timestamp.ToDeltaSinceWindowsEpoch().InMicroseconds());
@@ -1097,7 +1098,7 @@ TEST_F(TabRestoreServiceImplTest, TimestampSurvivesRestore) {
   {
     // |entry|/|tab| doesn't survive after RecreateService().
     Entry* entry = service_->entries().front().get();
-    ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+    ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
     Tab* tab = static_cast<Tab*>(entry);
     tab->timestamp = tab_timestamp;
     old_navigations = tab->navigations;
@@ -1119,7 +1120,7 @@ TEST_F(TabRestoreServiceImplTest, TimestampSurvivesRestore) {
 
   // And verify the entry.
   Entry* restored_entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, restored_entry->type);
   Tab* restored_tab = static_cast<Tab*>(restored_entry);
   EXPECT_EQ(
       tab_timestamp.ToDeltaSinceWindowsEpoch().InMicroseconds(),
@@ -1146,7 +1147,7 @@ TEST_F(TabRestoreServiceImplTest, StatusCodesSurviveRestore) {
   {
     // |entry|/|tab| doesn't survive after RecreateService().
     Entry* entry = service_->entries().front().get();
-    ASSERT_EQ(sessions::TabRestoreService::TAB, entry->type);
+    ASSERT_EQ(sessions::tab_restore::Type::TAB, entry->type);
     Tab* tab = static_cast<Tab*>(entry);
     old_navigations = tab->navigations;
   }
@@ -1167,7 +1168,7 @@ TEST_F(TabRestoreServiceImplTest, StatusCodesSurviveRestore) {
 
   // And verify the entry.
   Entry* restored_entry = service_->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::TAB, restored_entry->type);
+  ASSERT_EQ(sessions::tab_restore::Type::TAB, restored_entry->type);
   Tab* restored_tab = static_cast<Tab*>(restored_entry);
   ASSERT_EQ(old_navigations.size(), restored_tab->navigations.size());
   for (size_t i = 0; i < restored_tab->navigations.size(); ++i) {
@@ -1316,8 +1317,8 @@ TEST_F(TabRestoreServiceImplTest, TabGroupsRestoredFromSessionData) {
 
   ASSERT_EQ(2u, service_->entries().size());
   Entry* entry = service_->entries().back().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  auto* window = static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  auto* window = static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(1u, window->tabs.size());
   EXPECT_EQ(group, window->tabs[0]->group);
   EXPECT_EQ(group_visual_data, window->tab_groups[group]);
@@ -1343,8 +1344,8 @@ TEST_F(TabRestoreServiceImplTest, TabExtraDataRestoredFromSessionData) {
 
   ASSERT_EQ(2U, service_->entries().size());
   Entry* entry = service_->entries().back().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  auto* window = static_cast<sessions::TabRestoreService::Window*>(entry);
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  auto* window = static_cast<sessions::tab_restore::Window*>(entry);
   ASSERT_EQ(1U, window->tabs.size());
   ASSERT_EQ(1U, window->tabs[0]->extra_data.size());
   EXPECT_EQ(kSampleData, window->tabs[0]->extra_data[kSampleKey]);

chrome/browser/ui/android/tab_model/android_live_tab_context.cc

@@ -144,7 +144,7 @@ sessions::LiveTab* AndroidLiveTabContext::AddRestoredTab(
     const tab_groups::TabGroupVisualData& group_visual_data,
     bool select,
     bool pin,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data,
     const SessionID* tab_id) {
@@ -182,7 +182,7 @@ sessions::LiveTab* AndroidLiveTabContext::ReplaceRestoredTab(
     std::optional<tab_groups::TabGroupId> group,
     int selected_navigation,
     const std::string& extension_app_id,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data) {
   // Prepare navigation history.

chrome/browser/ui/android/tab_model/android_live_tab_context.h

@@ -69,7 +69,7 @@ class AndroidLiveTabContext : public sessions::LiveTabContext {
       const tab_groups::TabGroupVisualData& group_visual_data,
       bool select,
       bool pin,
-      const sessions::PlatformSpecificTabData* storage_namespace,
+      const sessions::tab_restore::PlatformSpecificTabData* storage_namespace,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data,
       const SessionID* tab_id) override;
@@ -78,7 +78,7 @@ class AndroidLiveTabContext : public sessions::LiveTabContext {
       std::optional<tab_groups::TabGroupId> group,
       int selected_navigation,
       const std::string& extension_app_id,
-      const sessions::PlatformSpecificTabData* tab_platform_data,
+      const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data) override;
   void CloseTab() override;

chrome/browser/ui/android/tab_model/android_live_tab_context_wrapper.cc

@@ -98,7 +98,7 @@ sessions::LiveTab* AndroidLiveTabContextRestoreWrapper::AddRestoredTab(
     const tab_groups::TabGroupVisualData& group_visual_data,
     bool select,
     bool pin,
-    const sessions::PlatformSpecificTabData* storage_namespace,
+    const sessions::tab_restore::PlatformSpecificTabData* storage_namespace,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data,
     const SessionID* tab_id) {

chrome/browser/ui/android/tab_model/android_live_tab_context_wrapper.h

@@ -136,7 +136,7 @@ class AndroidLiveTabContextRestoreWrapper : public AndroidLiveTabContext {
       const tab_groups::TabGroupVisualData& group_visual_data,
       bool select,
       bool pin,
-      const sessions::PlatformSpecificTabData* storage_namespace,
+      const sessions::tab_restore::PlatformSpecificTabData* storage_namespace,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data,
       const SessionID* tab_id) override;

chrome/browser/ui/browser_live_tab_context.cc

@@ -203,7 +203,7 @@ sessions::LiveTab* BrowserLiveTabContext::AddRestoredTab(
     const tab_groups::TabGroupVisualData& group_visual_data,
     bool select,
     bool pin,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data,
     const SessionID* tab_id) {
@@ -263,7 +263,7 @@ sessions::LiveTab* BrowserLiveTabContext::ReplaceRestoredTab(
     std::optional<tab_groups::TabGroupId> group,
     int selected_navigation,
     const std::string& extension_app_id,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data) {
   SessionStorageNamespace* storage_namespace =

chrome/browser/ui/browser_live_tab_context.h

@@ -76,7 +76,7 @@ class BrowserLiveTabContext : public sessions::LiveTabContext {
       const tab_groups::TabGroupVisualData& group_visual_data,
       bool select,
       bool pin,
-      const sessions::PlatformSpecificTabData* storage_namespace,
+      const sessions::tab_restore::PlatformSpecificTabData* storage_namespace,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data,
       const SessionID* tab_id) override;
@@ -85,7 +85,7 @@ class BrowserLiveTabContext : public sessions::LiveTabContext {
       std::optional<tab_groups::TabGroupId> group,
       int selected_navigation,
       const std::string& extension_app_id,
-      const sessions::PlatformSpecificTabData* tab_platform_data,
+      const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data) override;
   void CloseTab() override;

chrome/browser/ui/browser_tab_restorer.cc

@@ -145,7 +145,7 @@ std::unordered_set<std::string> GetUrlsInSavedTabGroup(
 
 content::WebContents* OpenTabWithNavigationStack(
     Browser* browser,
-    const sessions::TabRestoreService::Tab& restored_tab) {
+    const sessions::tab_restore::Tab& restored_tab) {
   const sessions::SerializedNavigationEntry& entry =
       restored_tab.navigations.at(restored_tab.normalized_navigation_index());
   const GURL tab_url = entry.virtual_url();
@@ -178,7 +178,7 @@ void AddMissingTabToGroup(
     Browser* const browser,
     tab_groups::SavedTabGroupKeyedService& saved_tab_group_service,
     const base::Uuid& saved_id,
-    const sessions::TabRestoreService::Tab& restored_tab,
+    const sessions::tab_restore::Tab& restored_tab,
     std::unordered_set<std::string>* const saved_urls) {
   const tab_groups::SavedTabGroup* const saved_group =
       saved_tab_group_service.model()->Get(saved_id);
@@ -211,7 +211,7 @@ void UpdateGroupVisualData(const tab_groups::TabGroupId& group_id,
 
 void OpenSavedTabGroupAndAddRestoredTabs(
     Browser* browser,
-    const sessions::TabRestoreService::Group& group,
+    const sessions::tab_restore::Group& group,
     tab_groups::SavedTabGroupKeyedService& saved_tab_group_service) {
   // service, saved id, group
   std::optional<tab_groups::TabGroupId> new_group_id =
@@ -224,7 +224,7 @@ void OpenSavedTabGroupAndAddRestoredTabs(
   // tabs that are not in the saved group are added to it.
   std::unordered_set<std::string> urls_in_saved_group = GetUrlsInSavedTabGroup(
       saved_tab_group_service, group.saved_group_id.value());
-  for (const std::unique_ptr<sessions::TabRestoreService::Tab>& grouped_tab :
+  for (const std::unique_ptr<sessions::tab_restore::Tab>& grouped_tab :
        group.tabs) {
     AddMissingTabToGroup(browser, saved_tab_group_service,
                          group.saved_group_id.value(), *grouped_tab.get(),
@@ -235,7 +235,7 @@ void OpenSavedTabGroupAndAddRestoredTabs(
 }
 
 void OpenTabGroup(sessions::TabRestoreService& tab_restore_service,
-                  const sessions::TabRestoreService::Group& group,
+                  const sessions::tab_restore::Group& group,
                   Browser* browser) {
   tab_groups::SavedTabGroupKeyedService* saved_tab_group_service =
       tab_groups::SavedTabGroupServiceFactory::GetForProfile(
@@ -269,7 +269,7 @@ void OpenTabGroup(sessions::TabRestoreService& tab_restore_service,
 }
 
 void OpenTab(sessions::TabRestoreService& tab_restore_service,
-             const sessions::TabRestoreService::Tab& tab,
+             const sessions::tab_restore::Tab& tab,
              Browser* browser) {
   tab_groups::SavedTabGroupKeyedService* saved_tab_group_service =
       tab_groups::SavedTabGroupServiceFactory::GetForProfile(
@@ -367,9 +367,8 @@ bool ShouldCreateAppWindowForAppName(Profile* profile,
   return apps::IsInstalledApp(profile, app_id);
 }
 
-Browser* CreateBrowserWindow(
-    Profile* profile,
-    const sessions::TabRestoreService::Window& window) {
+Browser* CreateBrowserWindow(Profile* profile,
+                             const sessions::tab_restore::Window& window) {
   std::unique_ptr<Browser::CreateParams> create_params;
   if (ShouldCreateAppWindowForAppName(profile, window.app_name)) {
     // Only trusted app popup windows should ever be restored.
@@ -399,7 +398,7 @@ Browser* CreateBrowserWindow(
 
 void RecreateAndSaveTabGroup(
     Browser* browser,
-    const sessions::TabRestoreService::Group& group,
+    const sessions::tab_restore::Group& group,
     tab_groups::SavedTabGroupKeyedService& saved_tab_group_service) {
   // If the group is not saved:
   //  0. Generate a new tab group id to avoid conflicts.
@@ -408,8 +407,7 @@ void RecreateAndSaveTabGroup(
   //  3. Save the group.
   tab_groups::TabGroupId new_id = tab_groups::TabGroupId::GenerateNew();
   std::vector<int> indices_of_tabs;
-  for (const std::unique_ptr<sessions::TabRestoreService::Tab>& tab :
-       group.tabs) {
+  for (const std::unique_ptr<sessions::tab_restore::Tab>& tab : group.tabs) {
     content::WebContents* opened_tab =
         OpenTabWithNavigationStack(browser, *tab.get());
     int index = browser->tab_strip_model()->GetIndexOfWebContents(opened_tab);
@@ -422,7 +420,7 @@ void RecreateAndSaveTabGroup(
 }
 
 void OpenWindow(sessions::TabRestoreService& tab_restore_service,
-                const sessions::TabRestoreService::Window& window,
+                const sessions::tab_restore::Window& window,
                 Browser* browser) {
   tab_groups::SavedTabGroupKeyedService* saved_tab_group_service =
       tab_groups::SavedTabGroupServiceFactory::GetForProfile(
@@ -434,8 +432,7 @@ void OpenWindow(sessions::TabRestoreService& tab_restore_service,
   // This should only be created when we actually need to open a new window.
   Browser* new_browser = nullptr;
 
-  for (const std::unique_ptr<sessions::TabRestoreService::Tab>& tab :
-       window.tabs) {
+  for (const std::unique_ptr<sessions::tab_restore::Tab>& tab : window.tabs) {
     if (!tab->group.has_value()) {
       if (!new_browser) {
         // Create a new browser window.
@@ -453,7 +450,7 @@ void OpenWindow(sessions::TabRestoreService& tab_restore_service,
     // Process all of the tabs in this group.
     seen_groups.emplace(tab->group.value().ToString());
 
-    const std::unique_ptr<sessions::TabRestoreService::Group>& group =
+    const std::unique_ptr<sessions::tab_restore::Group>& group =
         window.groups.at(tab->group.value());
     const tab_groups::SavedTabGroup* saved_group =
         group->saved_group_id.has_value()
@@ -518,26 +515,26 @@ void RestoreTab(Browser* browser) {
       return;
     }
 
-    const std::unique_ptr<sessions::TabRestoreService::Entry>&
-        most_recent_entry = service->entries().front();
+    const std::unique_ptr<sessions::tab_restore::Entry>& most_recent_entry =
+        service->entries().front();
     switch (most_recent_entry->type) {
-      case sessions::TabRestoreService::TAB: {
-        OpenTab(*service,
-                static_cast<sessions::TabRestoreService::Tab&>(
-                    *most_recent_entry.get()),
-                browser);
+      case sessions::tab_restore::Type::TAB: {
+        OpenTab(
+            *service,
+            static_cast<sessions::tab_restore::Tab&>(*most_recent_entry.get()),
+            browser);
         return;
       }
-      case sessions::TabRestoreService::WINDOW: {
+      case sessions::tab_restore::Type::WINDOW: {
         OpenWindow(*service,
-                   static_cast<sessions::TabRestoreService::Window&>(
+                   static_cast<sessions::tab_restore::Window&>(
                        *most_recent_entry.get()),
                    browser);
         return;
       }
-      case sessions::TabRestoreService::GROUP: {
+      case sessions::tab_restore::Type::GROUP: {
         OpenTabGroup(*service,
-                     static_cast<sessions::TabRestoreService::Group&>(
+                     static_cast<sessions::tab_restore::Group&>(
                          *most_recent_entry.get()),
                      browser);
         return;

chrome/browser/ui/cocoa/history_menu_bridge.h

@@ -191,14 +191,14 @@ class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
 
   // Adds an item for the window entry with a submenu containing its tabs.
   // Returns whether the item was successfully added.
-  bool AddWindowEntryToMenu(sessions::TabRestoreService::Window* window,
+  bool AddWindowEntryToMenu(sessions::tab_restore::Window* window,
                             NSMenu* menu,
                             NSInteger tag,
                             NSInteger index);
 
   // Adds an item for the group entry with a submenu containing its tabs.
   // Returns whether the item was successfully added.
-  bool AddGroupEntryToMenu(sessions::TabRestoreService::Group* group,
+  bool AddGroupEntryToMenu(sessions::tab_restore::Group* group,
                            NSMenu* menu,
                            NSInteger tag,
                            NSInteger index);
@@ -209,8 +209,7 @@ class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
   int AddTabsToSubmenu(
       NSMenu* submenu,
       HistoryItem* item,
-      const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>&
-          tabs);
+      const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs);
 
   // Called by the ctor if |service_| is ready at the time, or by a
   // notification receiver. Finishes initialization tasks by subscribing for
@@ -229,7 +228,7 @@ class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
 
   // Creates a HistoryItem* for the given tab entry.
   std::unique_ptr<HistoryItem> HistoryItemForTab(
-      const sessions::TabRestoreService::Tab& entry);
+      const sessions::tab_restore::Tab& entry);
 
   // Helper function that sends an async request to the FaviconService to get
   // an icon. The callback will update the NSMenuItem directly.

chrome/browser/ui/cocoa/history_menu_bridge.mm

@@ -145,24 +145,24 @@ void HistoryMenuBridge::TabRestoreServiceChanged(
   for (const auto& entry : entries) {
     if (added_count >= kRecentlyClosedCount)
       break;
-    if (entry->type == sessions::TabRestoreService::WINDOW) {
+    if (entry->type == sessions::tab_restore::Type::WINDOW) {
       bool added = AddWindowEntryToMenu(
-          static_cast<sessions::TabRestoreService::Window*>(entry.get()), menu,
+          static_cast<sessions::tab_restore::Window*>(entry.get()), menu,
           kRecentlyClosed, index);
       if (added) {
         ++index;
         ++added_count;
       }
-    } else if (entry->type == sessions::TabRestoreService::TAB) {
-      const auto& tab = static_cast<sessions::TabRestoreService::Tab&>(*entry);
+    } else if (entry->type == sessions::tab_restore::Type::TAB) {
+      const auto& tab = static_cast<sessions::tab_restore::Tab&>(*entry);
       std::unique_ptr<HistoryItem> item = HistoryItemForTab(tab);
       if (item) {
         AddItemToMenu(std::move(item), menu, kRecentlyClosed, index++);
         ++added_count;
       }
-    } else if (entry->type == sessions::TabRestoreService::GROUP) {
+    } else if (entry->type == sessions::tab_restore::Type::GROUP) {
       bool added = AddGroupEntryToMenu(
-          static_cast<sessions::TabRestoreService::Group*>(entry.get()), menu,
+          static_cast<sessions::tab_restore::Group*>(entry.get()), menu,
           kRecentlyClosed, index);
       if (added) {
         ++index;
@@ -303,11 +303,11 @@ NSMenuItem* HistoryMenuBridge::AddItemToMenu(std::unique_ptr<HistoryItem> item,
 }
 
 bool HistoryMenuBridge::AddWindowEntryToMenu(
-    sessions::TabRestoreService::Window* window,
+    sessions::tab_restore::Window* window,
     NSMenu* menu,
     NSInteger tag,
     NSInteger index) {
-  const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>& tabs =
+  const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs =
       window->tabs;
   if (tabs.empty())
     return false;
@@ -339,12 +339,11 @@ bool HistoryMenuBridge::AddWindowEntryToMenu(
   return true;
 }
 
-bool HistoryMenuBridge::AddGroupEntryToMenu(
-    sessions::TabRestoreService::Group* group,
-    NSMenu* menu,
-    NSInteger tag,
-    NSInteger index) {
-  const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>& tabs =
+bool HistoryMenuBridge::AddGroupEntryToMenu(sessions::tab_restore::Group* group,
+                                            NSMenu* menu,
+                                            NSInteger tag,
+                                            NSInteger index) {
+  const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs =
       group->tabs;
   if (tabs.empty())
     return false;
@@ -389,8 +388,7 @@ bool HistoryMenuBridge::AddGroupEntryToMenu(
 int HistoryMenuBridge::AddTabsToSubmenu(
     NSMenu* submenu,
     HistoryItem* item,
-    const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>&
-        tabs) {
+    const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs) {
   // Create standard items within the submenu.
   // Duplicate the HistoryItem otherwise the different NSMenuItems will
   // point to the same HistoryItem, which would then be double-freed when
@@ -504,8 +502,7 @@ void HistoryMenuBridge::OnVisitedHistoryResults(history::QueryResults results) {
 }
 
 std::unique_ptr<HistoryMenuBridge::HistoryItem>
-HistoryMenuBridge::HistoryItemForTab(
-    const sessions::TabRestoreService::Tab& entry) {
+HistoryMenuBridge::HistoryItemForTab(const sessions::tab_restore::Tab& entry) {
   DCHECK(!entry.navigations.empty());
 
   const sessions::SerializedNavigationEntry& current_navigation =

chrome/browser/ui/cocoa/history_menu_bridge_unittest.mm

@@ -47,10 +47,10 @@ class MockTRS : public sessions::TabRestoreServiceImpl {
   MOCK_CONST_METHOD0(entries, const sessions::TabRestoreService::Entries&());
 };
 
-MockTRS::Tab* CreateSessionTab(SessionID::id_type id,
-                               const std::string& url,
-                               const std::string& title) {
-  auto* tab = new MockTRS::Tab;
+sessions::tab_restore::Tab* CreateSessionTab(SessionID::id_type id,
+                                             const std::string& url,
+                                             const std::string& title) {
+  auto* tab = new sessions::tab_restore::Tab;
   tab->id = SessionID::FromSerializedValue(id);
   tab->current_navigation_index = 0;
   tab->navigations.push_back(
@@ -59,17 +59,17 @@ MockTRS::Tab* CreateSessionTab(SessionID::id_type id,
 }
 
 MockTRS::Entries CreateSessionEntries(
-    std::initializer_list<MockTRS::Entry*> entries) {
+    std::initializer_list<sessions::tab_restore::Entry*> entries) {
   MockTRS::Entries ret;
   for (auto* entry : entries)
     ret.emplace_back(entry);
   return ret;
 }
 
-MockTRS::Window* CreateSessionWindow(
+sessions::tab_restore::Window* CreateSessionWindow(
     SessionID::id_type id,
-    std::initializer_list<MockTRS::Tab*> tabs) {
-  auto* window = new MockTRS::Window;
+    std::initializer_list<sessions::tab_restore::Tab*> tabs) {
+  auto* window = new sessions::tab_restore::Window;
   window->id = SessionID::FromSerializedValue(id);
   window->tabs.reserve(tabs.size());
   for (auto* tab : tabs)
@@ -77,10 +77,11 @@ MockTRS::Window* CreateSessionWindow(
   return window;
 }
 
-MockTRS::Group* CreateSessionGroup(SessionID::id_type id,
-                                   tab_groups::TabGroupVisualData visual_data,
-                                   std::initializer_list<MockTRS::Tab*> tabs) {
-  auto* group = new MockTRS::Group;
+sessions::tab_restore::Group* CreateSessionGroup(
+    SessionID::id_type id,
+    tab_groups::TabGroupVisualData visual_data,
+    std::initializer_list<sessions::tab_restore::Tab*> tabs) {
+  auto* group = new sessions::tab_restore::Group;
   group->id = SessionID::FromSerializedValue(id);
   group->visual_data = visual_data;
   group->tabs.reserve(tabs.size());

chrome/browser/ui/tabs/recent_tabs_sub_menu_model.cc

@@ -376,21 +376,19 @@ void RecentTabsSubMenuModel::BuildLocalEntries() {
         break;
       }
       switch (entry->type) {
-        case sessions::TabRestoreService::TAB: {
-          auto& tab =
-              static_cast<const sessions::TabRestoreService::Tab&>(*entry);
+        case sessions::tab_restore::Type::TAB: {
+          auto& tab = static_cast<const sessions::tab_restore::Tab&>(*entry);
           BuildLocalTabItem(tab, ++last_local_model_index_);
           break;
         }
-        case sessions::TabRestoreService::WINDOW: {
-          auto& window =
-              static_cast<sessions::TabRestoreService::Window&>(*entry);
+        case sessions::tab_restore::Type::WINDOW: {
+          auto& window = static_cast<sessions::tab_restore::Window&>(*entry);
           BuildLocalWindowItem(window, ++last_local_model_index_);
           break;
         }
-        case sessions::TabRestoreService::GROUP: {
+        case sessions::tab_restore::Type::GROUP: {
           auto& group =
-              static_cast<const sessions::TabRestoreService::Group&>(*entry);
+              static_cast<const sessions::tab_restore::Group&>(*entry);
           BuildLocalGroupItem(group, ++last_local_model_index_);
           break;
         }
@@ -461,7 +459,7 @@ void RecentTabsSubMenuModel::BuildTabsFromOtherDevices() {
 }
 
 void RecentTabsSubMenuModel::BuildLocalTabItem(
-    const sessions::TabRestoreService::Tab& tab,
+    const sessions::tab_restore::Tab& tab,
     size_t curr_model_index) {
   const int command_id = GetAndIncrementNextMenuID();
   const sessions::SerializedNavigationEntry& current_navigation =
@@ -495,7 +493,7 @@ void RecentTabsSubMenuModel::BuildLocalTabItem(
 }
 
 void RecentTabsSubMenuModel::BuildLocalWindowItem(
-    const sessions::TabRestoreService::Window& window,
+    const sessions::tab_restore::Window& window,
     size_t curr_model_index) {
   const int command_id = GetAndIncrementNextMenuID();
   std::unique_ptr<ui::SimpleMenuModel> window_model =
@@ -511,7 +509,7 @@ void RecentTabsSubMenuModel::BuildLocalWindowItem(
 }
 
 void RecentTabsSubMenuModel::BuildLocalGroupItem(
-    const sessions::TabRestoreService::Group& group,
+    const sessions::tab_restore::Group& group,
     size_t curr_model_index) {
   // Set the item label to the name of the group and the number of
   // tabs.
@@ -567,7 +565,7 @@ RecentTabsSubMenuModel::CreateOtherDeviceSubMenu(
 
 std::unique_ptr<ui::SimpleMenuModel>
 RecentTabsSubMenuModel::CreateWindowSubMenuModel(
-    const sessions::TabRestoreService::Window& window) {
+    const sessions::tab_restore::Window& window) {
   std::unique_ptr<ui::SimpleMenuModel> window_model =
       std::make_unique<ui::SimpleMenuModel>(this);
   const int restore_all_command_id = GetAndIncrementNextMenuID();
@@ -580,8 +578,7 @@ RecentTabsSubMenuModel::CreateWindowSubMenuModel(
   std::optional<tab_groups::TabGroupId> last_group;
   tab_groups::TabGroupVisualData current_group_visual_data;
   std::unique_ptr<ui::SimpleMenuModel> current_group_model;
-  for (const std::unique_ptr<sessions::TabRestoreService::Tab>& tab :
-       window.tabs) {
+  for (const std::unique_ptr<sessions::tab_restore::Tab>& tab : window.tabs) {
     const int tab_command_id = GetAndIncrementNextMenuID();
     if (tab->group != last_group && current_group_model) {
       AddGroupItemToModel(window_model.get(), std::move(current_group_model),
@@ -618,7 +615,7 @@ RecentTabsSubMenuModel::CreateWindowSubMenuModel(
 
 std::unique_ptr<ui::SimpleMenuModel>
 RecentTabsSubMenuModel::CreateGroupSubMenuModel(
-    const sessions::TabRestoreService::Group& group) {
+    const sessions::tab_restore::Group& group) {
   std::unique_ptr<ui::SimpleMenuModel> group_model =
       std::make_unique<ui::SimpleMenuModel>(this);
   int command_id = GetAndIncrementNextMenuID();
@@ -661,7 +658,7 @@ void RecentTabsSubMenuModel::AddGroupItemToModel(
 }
 
 void RecentTabsSubMenuModel::AddTabItemToModel(
-    const sessions::TabRestoreService::Tab* tab,
+    const sessions::tab_restore::Tab* tab,
     ui::SimpleMenuModel* model,
     int command_id) {
   const sessions::SerializedNavigationEntry& current_navigation =

chrome/browser/ui/tabs/recent_tabs_sub_menu_model.h

@@ -117,17 +117,17 @@ class RecentTabsSubMenuModel : public ui::SimpleMenuModel,
 
   // Build a recently closed tab item with parameters needed to restore it, and
   // add it to the menumodel at |curr_model_index|.
-  void BuildLocalTabItem(const sessions::TabRestoreService::Tab& tab,
+  void BuildLocalTabItem(const sessions::tab_restore::Tab& tab,
                          size_t curr_model_index);
 
   // Build the recently closed window item with parameters needed to restore it,
   // and add it to the menumodel at |curr_model_index|.
-  void BuildLocalWindowItem(const sessions::TabRestoreService::Window& window,
+  void BuildLocalWindowItem(const sessions::tab_restore::Window& window,
                             size_t curr_model_index);
 
   // Build the recently closed group item with parameters needed to restore it,
   // and add it to the menumodel at |curr_model_index|.
-  void BuildLocalGroupItem(const sessions::TabRestoreService::Group& group,
+  void BuildLocalGroupItem(const sessions::tab_restore::Group& group,
                            size_t curr_model_index);
 
   // Build the tab item for other devices with parameters needed to restore it.
@@ -142,11 +142,11 @@ class RecentTabsSubMenuModel : public ui::SimpleMenuModel,
 
   // Create a submenu model representing the tabs within a window.
   std::unique_ptr<ui::SimpleMenuModel> CreateWindowSubMenuModel(
-      const sessions::TabRestoreService::Window& window);
+      const sessions::tab_restore::Window& window);
 
   // Create a submenu model representing the tabs within a tab group.
   std::unique_ptr<ui::SimpleMenuModel> CreateGroupSubMenuModel(
-      const sessions::TabRestoreService::Group& group);
+      const sessions::tab_restore::Group& group);
 
   // Adds a submenu item representation of |group_model| to |parent_model|.
   void AddGroupItemToModel(SimpleMenuModel* parent_model,
@@ -154,7 +154,7 @@ class RecentTabsSubMenuModel : public ui::SimpleMenuModel,
                            tab_groups::TabGroupVisualData group_visual_data);
 
   // Adds a submenu item representation of a |tab| to |model|.
-  void AddTabItemToModel(const sessions::TabRestoreService::Tab* tab,
+  void AddTabItemToModel(const sessions::tab_restore::Tab* tab,
                          ui::SimpleMenuModel* model,
                          int command_id);
 

chrome/browser/ui/views/frame/dbus_appmenu.cc

@@ -321,7 +321,7 @@ ui::SimpleMenuModel* DbusAppmenu::BuildStaticMenu(
 }
 
 std::unique_ptr<DbusAppmenu::HistoryItem> DbusAppmenu::HistoryItemForTab(
-    const sessions::TabRestoreService::Tab& entry) {
+    const sessions::tab_restore::Tab& entry) {
   const sessions::SerializedNavigationEntry& current_navigation =
       entry.navigations.at(entry.current_navigation_index);
   auto item = std::make_unique<HistoryItem>();
@@ -350,8 +350,7 @@ void DbusAppmenu::AddEntryToHistoryMenu(
     SessionID id,
     std::u16string title,
     int index,
-    const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>&
-        tabs) {
+    const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs) {
   // Create the item for the parent/window.
   auto item = std::make_unique<HistoryItem>();
   item->session_id = id;
@@ -502,11 +501,11 @@ void DbusAppmenu::TabRestoreServiceChanged(
   unsigned int added_count = 0;
   for (auto it = entries.begin();
        it != entries.end() && added_count < kRecentlyClosedCount; ++it) {
-    sessions::TabRestoreService::Entry* entry = it->get();
+    sessions::tab_restore::Entry* entry = it->get();
 
-    if (entry->type == sessions::TabRestoreService::WINDOW) {
-      sessions::TabRestoreService::Window* window =
-          static_cast<sessions::TabRestoreService::Window*>(entry);
+    if (entry->type == sessions::tab_restore::Type::WINDOW) {
+      sessions::tab_restore::Window* window =
+          static_cast<sessions::tab_restore::Window*>(entry);
 
       auto& tabs = window->tabs;
       if (tabs.empty())
@@ -517,14 +516,14 @@ void DbusAppmenu::TabRestoreServiceChanged(
 
       AddEntryToHistoryMenu(window->id, title, index++, tabs);
       ++added_count;
-    } else if (entry->type == sessions::TabRestoreService::TAB) {
-      sessions::TabRestoreService::Tab* tab =
-          static_cast<sessions::TabRestoreService::Tab*>(entry);
+    } else if (entry->type == sessions::tab_restore::Type::TAB) {
+      sessions::tab_restore::Tab* tab =
+          static_cast<sessions::tab_restore::Tab*>(entry);
       AddHistoryItemToMenu(HistoryItemForTab(*tab), history_menu_, index++);
       ++added_count;
-    } else if (entry->type == sessions::TabRestoreService::GROUP) {
-      sessions::TabRestoreService::Group* group =
-          static_cast<sessions::TabRestoreService::Group*>(entry);
+    } else if (entry->type == sessions::tab_restore::Type::GROUP) {
+      sessions::tab_restore::Group* group =
+          static_cast<sessions::tab_restore::Group*>(entry);
 
       auto& tabs = group->tabs;
       if (tabs.empty())

chrome/browser/ui/views/frame/dbus_appmenu.h

@@ -72,7 +72,7 @@ class DbusAppmenu : public AvatarMenuObserver,
 
   // Creates a HistoryItem from the data in |entry|.
   std::unique_ptr<HistoryItem> HistoryItemForTab(
-      const sessions::TabRestoreService::Tab& entry);
+      const sessions::tab_restore::Tab& entry);
 
   // Creates a menu item form |item| and inserts it in |menu| at |index|.
   void AddHistoryItemToMenu(std::unique_ptr<HistoryItem> item,
@@ -86,8 +86,7 @@ class DbusAppmenu : public AvatarMenuObserver,
       SessionID id,
       std::u16string title,
       int index,
-      const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>&
-          tabs);
+      const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs);
 
   // Sends a message off to History for data.
   void GetTopSitesData();

chrome/browser/ui/views/frame/system_menu_model_delegate.cc

@@ -97,10 +97,10 @@ std::u16string SystemMenuModelDelegate::GetLabelForCommandId(
     DCHECK(trs);
     trs->LoadTabsFromLastSession();
     if (!trs->entries().empty()) {
-      if (trs->entries().front()->type == sessions::TabRestoreService::WINDOW) {
+      if (trs->entries().front()->type == sessions::tab_restore::Type::WINDOW) {
         string_id = IDS_REOPEN_WINDOW;
       } else if (trs->entries().front()->type ==
-                 sessions::TabRestoreService::GROUP) {
+                 sessions::tab_restore::Type::GROUP) {
         string_id = IDS_REOPEN_GROUP;
       }
     }

chrome/browser/ui/views/toolbar/app_menu_browsertest.cc

@@ -209,8 +209,8 @@ IN_PROC_BROWSER_TEST_F(AppMenuBrowserTest, ShowWithRecentlyClosedWindow) {
   chrome::CloseWindow(second_browser);
   ui_test_utils::WaitForBrowserToClose(second_browser);
   EXPECT_TRUE(base::Contains(tab_restore_service->entries(),
-                             sessions::TabRestoreService::WINDOW,
-                             &sessions::TabRestoreService::Entry::type));
+                             sessions::tab_restore::Type::WINDOW,
+                             &sessions::tab_restore::Entry::type));
 
   // Show the AppMenu.
   menu_button()->ShowMenu(views::MenuRunner::NO_FLAGS);

chrome/browser/ui/web_applications/web_app_tab_restore_browsertest.cc

@@ -48,10 +48,9 @@ IN_PROC_BROWSER_TEST_F(WebAppTabRestoreBrowserTest,
   sessions::TabRestoreService* const service =
       TabRestoreServiceFactory::GetForProfile(profile());
   ASSERT_GT(service->entries().size(), 0U);
-  sessions::TabRestoreService::Entry* entry = service->entries().front().get();
-  ASSERT_EQ(sessions::TabRestoreService::WINDOW, entry->type);
-  const auto* entry_win =
-      static_cast<sessions::TabRestoreService::Window*>(entry);
+  sessions::tab_restore::Entry* entry = service->entries().front().get();
+  ASSERT_EQ(sessions::tab_restore::Type::WINDOW, entry->type);
+  const auto* entry_win = static_cast<sessions::tab_restore::Window*>(entry);
   EXPECT_EQ(bounds, entry_win->bounds);
 
   service->RestoreMostRecentEntry(nullptr);

chrome/browser/ui/webui/tab_search/tab_search_page_handler.cc

@@ -82,8 +82,7 @@ std::string GetLastActiveElapsedText(const base::Time& last_active_time) {
 // If Tab Group has no timestamp, we find the tab in the tab group with
 // the most recent navigation last active time.
 base::Time GetTabGroupTimeStamp(
-    const std::vector<std::unique_ptr<sessions::TabRestoreService::Tab>>&
-        tabs) {
+    const std::vector<std::unique_ptr<sessions::tab_restore::Tab>>& tabs) {
   base::Time last_active_time;
   for (const auto& tab : tabs) {
     const sessions::SerializedNavigationEntry& entry =
@@ -98,7 +97,7 @@ base::Time GetTabGroupTimeStamp(
 // open we create a TabGroup entry with the required fields to support
 // rendering the tab's associated group information in the UI.
 void CreateTabGroupIfNotPresent(
-    sessions::TabRestoreService::Tab* tab,
+    sessions::tab_restore::Tab* tab,
     std::set<tab_groups::TabGroupId>& tab_group_ids,
     std::vector<tab_search::mojom::TabGroupPtr>& tab_groups) {
   if (tab->group.has_value() &&
@@ -793,13 +792,13 @@ void TabSearchPageHandler::AddRecentlyClosedEntries(
       return;
     }
 
-    if (entry->type == sessions::TabRestoreService::Type::WINDOW) {
-      sessions::TabRestoreService::Window* window =
-          static_cast<sessions::TabRestoreService::Window*>(entry.get());
+    if (entry->type == sessions::tab_restore::Type::WINDOW) {
+      sessions::tab_restore::Window* window =
+          static_cast<sessions::tab_restore::Window*>(entry.get());
 
       for (auto& window_tab : window->tabs) {
-        sessions::TabRestoreService::Tab* tab =
-            static_cast<sessions::TabRestoreService::Tab*>(window_tab.get());
+        sessions::tab_restore::Tab* tab =
+            static_cast<sessions::tab_restore::Tab*>(window_tab.get());
         if (AddRecentlyClosedTab(tab, entry->timestamp, recently_closed_tabs,
                                  tab_dedup_keys, tab_group_ids, tab_groups)) {
           recently_closed_tab_count += 1;
@@ -811,18 +810,18 @@ void TabSearchPageHandler::AddRecentlyClosedEntries(
           return;
         }
       }
-    } else if (entry->type == sessions::TabRestoreService::Type::TAB) {
-      sessions::TabRestoreService::Tab* tab =
-          static_cast<sessions::TabRestoreService::Tab*>(entry.get());
+    } else if (entry->type == sessions::tab_restore::Type::TAB) {
+      sessions::tab_restore::Tab* tab =
+          static_cast<sessions::tab_restore::Tab*>(entry.get());
 
       if (AddRecentlyClosedTab(tab, entry->timestamp, recently_closed_tabs,
                                tab_dedup_keys, tab_group_ids, tab_groups)) {
         recently_closed_tab_count += 1;
         recently_closed_item_count += 1;
       }
-    } else if (entry->type == sessions::TabRestoreService::Type::GROUP) {
-      sessions::TabRestoreService::Group* group =
-          static_cast<sessions::TabRestoreService::Group*>(entry.get());
+    } else if (entry->type == sessions::tab_restore::Type::GROUP) {
+      sessions::tab_restore::Group* group =
+          static_cast<sessions::tab_restore::Group*>(entry.get());
 
       const tab_groups::TabGroupVisualData* tab_group_visual_data =
           &group->visual_data;
@@ -858,7 +857,7 @@ void TabSearchPageHandler::AddRecentlyClosedEntries(
 }
 
 bool TabSearchPageHandler::AddRecentlyClosedTab(
-    sessions::TabRestoreService::Tab* tab,
+    sessions::tab_restore::Tab* tab,
     const base::Time& close_time,
     std::vector<tab_search::mojom::RecentlyClosedTabPtr>& recently_closed_tabs,
     std::set<DedupKey>& tab_dedup_keys,
@@ -960,9 +959,8 @@ tab_search::mojom::TabPtr TabSearchPageHandler::GetTab(
 }
 
 tab_search::mojom::RecentlyClosedTabPtr
-TabSearchPageHandler::GetRecentlyClosedTab(
-    sessions::TabRestoreService::Tab* tab,
-    const base::Time& close_time) {
+TabSearchPageHandler::GetRecentlyClosedTab(sessions::tab_restore::Tab* tab,
+                                           const base::Time& close_time) {
   auto recently_closed_tab = tab_search::mojom::RecentlyClosedTab::New();
   DCHECK(tab->navigations.size() > 0);
   sessions::SerializedNavigationEntry& entry =
@@ -1017,13 +1015,13 @@ void TabSearchPageHandler::OnTabStripModelChanged(
       // Loops through at most (TabRestoreServiceHelper) kMaxEntries.
       // Recently closed entries appear first in the list.
       for (auto& entry : tab_restore_service->entries()) {
-        if (entry->type == sessions::TabRestoreService::Type::TAB &&
+        if (entry->type == sessions::tab_restore::Type::TAB &&
             base::Contains(tab_restore_ids, entry->id)) {
           // The associated tab group visual data for the recently closed tab is
           // already present at the client side from the initial GetProfileData
           // call.
-          sessions::TabRestoreService::Tab* tab =
-              static_cast<sessions::TabRestoreService::Tab*>(entry.get());
+          sessions::tab_restore::Tab* tab =
+              static_cast<sessions::tab_restore::Tab*>(entry.get());
           tab_search::mojom::RecentlyClosedTabPtr recently_closed_tab =
               GetRecentlyClosedTab(tab, entry->timestamp);
           tabs_removed_info->recently_closed_tabs.push_back(

chrome/browser/ui/webui/tab_search/tab_search_page_handler.h

@@ -176,7 +176,7 @@ class TabSearchPageHandler
   // Tries to add a recently closed tab to the profile data.
   // Returns true if a recently closed tab was added to `recently_closed_tabs`
   bool AddRecentlyClosedTab(
-      sessions::TabRestoreService::Tab* tab,
+      sessions::tab_restore::Tab* tab,
       const base::Time& close_time,
       std::vector<tab_search::mojom::RecentlyClosedTabPtr>&
           recently_closed_tabs,
@@ -188,7 +188,7 @@ class TabSearchPageHandler
                                    content::WebContents* contents,
                                    int index) const;
   tab_search::mojom::RecentlyClosedTabPtr GetRecentlyClosedTab(
-      sessions::TabRestoreService::Tab* tab,
+      sessions::tab_restore::Tab* tab,
       const base::Time& close_time);
 
   // Returns tab details required to perform an action on the tab.

chrome/browser/win/jumplist.cc

@@ -427,17 +427,16 @@ void JumpList::ProcessTabRestoreServiceNotification() {
     if (recently_closed_pages_.size() >= kRecentlyClosedItems)
       break;
     switch (entry->type) {
-      case sessions::TabRestoreService::TAB:
-        AddTab(static_cast<const sessions::TabRestoreService::Tab&>(*entry),
+      case sessions::tab_restore::Type::TAB:
+        AddTab(static_cast<const sessions::tab_restore::Tab&>(*entry),
                profile_dir, kRecentlyClosedItems);
         break;
-      case sessions::TabRestoreService::WINDOW:
-        AddWindow(
-            static_cast<const sessions::TabRestoreService::Window&>(*entry),
-            profile_dir, kRecentlyClosedItems);
+      case sessions::tab_restore::Type::WINDOW:
+        AddWindow(static_cast<const sessions::tab_restore::Window&>(*entry),
+                  profile_dir, kRecentlyClosedItems);
         break;
-      case sessions::TabRestoreService::GROUP:
-        AddGroup(static_cast<const sessions::TabRestoreService::Group&>(*entry),
+      case sessions::tab_restore::Type::GROUP:
+        AddGroup(static_cast<const sessions::tab_restore::Group&>(*entry),
                  profile_dir, kRecentlyClosedItems);
         break;
     }
@@ -482,7 +481,7 @@ void JumpList::OnMostVisitedURLsAvailable(
   StartLoadingFavicon();
 }
 
-bool JumpList::AddTab(const sessions::TabRestoreService::Tab& tab,
+bool JumpList::AddTab(const sessions::tab_restore::Tab& tab,
                       const base::FilePath& cmd_line_profile_dir,
                       size_t max_items) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@@ -508,7 +507,7 @@ bool JumpList::AddTab(const sessions::TabRestoreService::Tab& tab,
   return true;
 }
 
-void JumpList::AddWindow(const sessions::TabRestoreService::Window& window,
+void JumpList::AddWindow(const sessions::tab_restore::Window& window,
                          const base::FilePath& cmd_line_profile_dir,
                          size_t max_items) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@@ -520,7 +519,7 @@ void JumpList::AddWindow(const sessions::TabRestoreService::Window& window,
   }
 }
 
-void JumpList::AddGroup(const sessions::TabRestoreService::Group& group,
+void JumpList::AddGroup(const sessions::tab_restore::Group& group,
                         const base::FilePath& cmd_line_profile_dir,
                         size_t max_items) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

chrome/browser/win/jumplist.h

@@ -172,7 +172,7 @@ class JumpList : public sessions::TabRestoreServiceObserver,
   // Adds a new ShellLinkItem for |tab| to the JumpList data provided that doing
   // so will not exceed |max_items|. If |cmd_line_profile_dir| is not empty,
   // it will be added to the command line switch --profile-directory.
-  bool AddTab(const sessions::TabRestoreService::Tab& tab,
+  bool AddTab(const sessions::tab_restore::Tab& tab,
               const base::FilePath& cmd_line_profile_dir,
               size_t max_items);
 
@@ -180,7 +180,7 @@ class JumpList : public sessions::TabRestoreServiceObserver,
   // provided that doing so will not exceed |max_items|. If
   // |cmd_line_profile_dir| is not empty, it will be added to the command line
   // switch --profile-directory.
-  void AddWindow(const sessions::TabRestoreService::Window& window,
+  void AddWindow(const sessions::tab_restore::Window& window,
                  const base::FilePath& cmd_line_profile_dir,
                  size_t max_items);
 
@@ -188,7 +188,7 @@ class JumpList : public sessions::TabRestoreServiceObserver,
   // provided that doing so will not exceed |max_items|. If
   // |cmd_line_profile_dir| is not empty, it will be added to the command line
   // switch --profile-directory.
-  void AddGroup(const sessions::TabRestoreService::Group& group,
+  void AddGroup(const sessions::tab_restore::Group& group,
                 const base::FilePath& cmd_line_profile_dir,
                 size_t max_items);
 

components/sessions/BUILD.gn

@@ -120,7 +120,6 @@ source_set("shared") {
     "core/session_service_commands.h",
     "core/session_types.cc",
     "core/session_types.h",
-    "core/tab_restore_service.cc",
     "core/tab_restore_service.h",
     "core/tab_restore_service_client.cc",
     "core/tab_restore_service_client.h",
@@ -129,6 +128,8 @@ source_set("shared") {
     "core/tab_restore_service_impl.cc",
     "core/tab_restore_service_impl.h",
     "core/tab_restore_service_observer.h",
+    "core/tab_restore_types.cc",
+    "core/tab_restore_types.h",
   ]
 
   configs += [ ":implementation" ]

components/sessions/content/content_live_tab.cc

@@ -59,7 +59,7 @@ int ContentLiveTab::GetEntryCount() {
   return navigation_controller().GetEntryCount();
 }
 
-std::unique_ptr<sessions::PlatformSpecificTabData>
+std::unique_ptr<tab_restore::PlatformSpecificTabData>
 ContentLiveTab::GetPlatformSpecificTabData() {
   return std::make_unique<sessions::ContentPlatformSpecificTabData>(
       web_contents());

components/sessions/content/content_live_tab.h

@@ -42,8 +42,8 @@ class SESSIONS_EXPORT ContentLiveTab
   sessions::SerializedNavigationEntry GetEntryAtIndex(int index) override;
   sessions::SerializedNavigationEntry GetPendingEntry() override;
   int GetEntryCount() override;
-  std::unique_ptr<PlatformSpecificTabData> GetPlatformSpecificTabData()
-      override;
+  std::unique_ptr<tab_restore::PlatformSpecificTabData>
+  GetPlatformSpecificTabData() override;
   SerializedUserAgentOverride GetUserAgentOverride() override;
 
   content::WebContents* web_contents() { return web_contents_; }

components/sessions/content/content_platform_specific_tab_data.h

@@ -17,11 +17,11 @@ class WebContents;
 namespace sessions {
 
 // A //content-specific subclass of PlatformSpecificTabData that is used to
-// associate TabRestoreService::Tab instances with the
+// associate tab_restore::Tab instances with the
 // content::SessionStorageNamespace of the WebContents from which they were
 // created.
 class SESSIONS_EXPORT ContentPlatformSpecificTabData
-    : public PlatformSpecificTabData {
+    : public tab_restore::PlatformSpecificTabData {
  public:
   explicit ContentPlatformSpecificTabData(content::WebContents* web_contents);
   ContentPlatformSpecificTabData();

components/sessions/core/live_tab.cc

@@ -8,7 +8,8 @@ namespace sessions {
 
 LiveTab::~LiveTab() {}
 
-std::unique_ptr<PlatformSpecificTabData> LiveTab::GetPlatformSpecificTabData() {
+std::unique_ptr<tab_restore::PlatformSpecificTabData>
+LiveTab::GetPlatformSpecificTabData() {
   return nullptr;
 }
 

components/sessions/core/live_tab.h

@@ -29,9 +29,10 @@ class SESSIONS_EXPORT LiveTab {
   virtual int GetEntryCount() = 0;
 
   // Returns any platform-specific data that should be associated with the
-  // TabRestoreService::Tab corresponding to this instance. The default
+  // tab_restore::Tab corresponding to this instance. The default
   // implementation returns null.
-  virtual std::unique_ptr<PlatformSpecificTabData> GetPlatformSpecificTabData();
+  virtual std::unique_ptr<tab_restore::PlatformSpecificTabData>
+  GetPlatformSpecificTabData();
 
   // Returns the user agent override, if any.
   virtual SerializedUserAgentOverride GetUserAgentOverride() = 0;

components/sessions/core/live_tab_context.h

@@ -13,6 +13,7 @@
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sessions/core/sessions_export.h"
+#include "components/sessions/core/tab_restore_types.h"
 #include "components/tab_groups/tab_group_id.h"
 #include "components/tab_groups/tab_group_visual_data.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ -30,7 +31,6 @@ namespace sessions {
 
 class LiveTab;
 class SerializedNavigationEntry;
-class PlatformSpecificTabData;
 
 // An interface representing the context in which LiveTab instances exist in the
 // embedder. As a concrete example, desktop Chrome has an implementation that
@@ -82,7 +82,7 @@ class SESSIONS_EXPORT LiveTabContext {
       const tab_groups::TabGroupVisualData& group_visual_data,
       bool select,
       bool pin,
-      const PlatformSpecificTabData* tab_platform_data,
+      const tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data,
       const SessionID* tab_id) = 0;
@@ -95,7 +95,7 @@ class SESSIONS_EXPORT LiveTabContext {
       std::optional<tab_groups::TabGroupId> group,
       int selected_navigation,
       const std::string& extension_app_id,
-      const PlatformSpecificTabData* tab_platform_data,
+      const tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data) = 0;
   virtual void CloseTab() = 0;

components/sessions/core/tab_restore_service.cc

@@ -1,66 +0,0 @@
-// Copyright 2012 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/sessions/core/tab_restore_service.h"
-
-#include "base/trace_event/memory_usage_estimator.h"
-#include "components/tab_groups/tab_group_id.h"
-#include "components/tab_groups/tab_group_visual_data.h"
-
-namespace sessions {
-
-// TimeFactory-----------------------------------------------------------------
-
-TabRestoreService::TimeFactory::~TimeFactory() {}
-
-// Entry ----------------------------------------------------------------------
-
-TabRestoreService::Entry::~Entry() = default;
-
-TabRestoreService::Entry::Entry(Type type)
-    : id(SessionID::NewUnique()),
-      original_id(SessionID::InvalidValue()),
-      type(type) {}
-
-size_t TabRestoreService::Entry::EstimateMemoryUsage() const {
-  return 0;
-}
-
-TabRestoreService::Tab::Tab() : Entry(TAB) {}
-TabRestoreService::Tab::~Tab() = default;
-
-size_t TabRestoreService::Tab::EstimateMemoryUsage() const {
-  using base::trace_event::EstimateMemoryUsage;
-  return EstimateMemoryUsage(navigations) +
-         EstimateMemoryUsage(extension_app_id) +
-         user_agent_override.EstimateMemoryUsage();
-}
-
-TabRestoreService::Window::Window() : Entry(WINDOW) {}
-TabRestoreService::Window::~Window() = default;
-
-size_t TabRestoreService::Window::EstimateMemoryUsage() const {
-  using base::trace_event::EstimateMemoryUsage;
-  return EstimateMemoryUsage(tabs) + EstimateMemoryUsage(app_name);
-}
-
-TabRestoreService::Group::Group() : Entry(GROUP) {}
-TabRestoreService::Group::~Group() = default;
-
-size_t TabRestoreService::Group::EstimateMemoryUsage() const {
-  using base::trace_event::EstimateMemoryUsage;
-  return EstimateMemoryUsage(tabs) + EstimateMemoryUsage(visual_data.title());
-}
-
-// TabRestoreService ----------------------------------------------------------
-
-TabRestoreService::~TabRestoreService() {
-}
-
-// PlatformSpecificTabData
-// ------------------------------------------------------
-
-PlatformSpecificTabData::~PlatformSpecificTabData() {}
-
-}  // namespace sessions

components/sessions/core/tab_restore_service.h

@@ -22,6 +22,7 @@
 #include "components/sessions/core/session_id.h"
 #include "components/sessions/core/session_types.h"
 #include "components/sessions/core/sessions_export.h"
+#include "components/sessions/core/tab_restore_types.h"
 #include "components/tab_groups/tab_group_id.h"
 #include "components/tab_groups/tab_group_visual_data.h"
 #include "ui/base/ui_base_types.h"
@@ -31,7 +32,6 @@
 namespace sessions {
 
 class LiveTab;
-class PlatformSpecificTabData;
 class TabRestoreServiceObserver;
 
 // TabRestoreService is responsible for maintaining the most recently closed
@@ -49,180 +49,11 @@ class TabRestoreServiceObserver;
 // add an observer.
 class SESSIONS_EXPORT TabRestoreService : public KeyedService {
  public:
-  struct Tab;
-  struct Window;
-  struct Group;
-
-  // Interface used to allow the test to provide a custom time.
-  class SESSIONS_EXPORT TimeFactory {
-   public:
-    virtual ~TimeFactory();
-    virtual base::Time TimeNow() = 0;
-  };
-
-  // The type of entry.
-  enum Type {
-    TAB,
-    WINDOW,
-    GROUP,
-  };
-
-  struct SESSIONS_EXPORT Entry {
-    Entry(const Entry&) = delete;
-    Entry& operator=(const Entry&) = delete;
-
-    virtual ~Entry();
-
-    // Unique id for this entry. The id is guaranteed to be unique for a
-    // session.
-    SessionID id;
-
-    // The original id of the entry when it was saved.
-    SessionID original_id;
-
-    // The type of the entry.
-    const Type type;
-
-    // The time when the window, tab, or group was closed. Not always set - can
-    // be nullptr or 0 in cases where a timestamp isn't available at entry
-    // creation.
-    base::Time timestamp;
-
-    // Used for storing arbitrary key/value pairs.
-    std::map<std::string, std::string> extra_data;
-
-    // Estimates memory usage. By default returns 0.
-    virtual size_t EstimateMemoryUsage() const;
-
-   protected:
-    explicit Entry(Type type);
-  };
-
-  // Represents a previously open tab.
-  // If you add a new field that can allocate memory, please also add
-  // it to the EstimatedMemoryUsage() implementation.
-  struct SESSIONS_EXPORT Tab : public Entry {
-    Tab();
-    ~Tab() override;
-
-    // Entry:
-    size_t EstimateMemoryUsage() const override;
-
-    // Since the current_navigation_index can be larger than the index for
-    // number of navigations in the current sessions (chrome://newtab is not
-    // stored), we must perform bounds checking. Returns a normalized
-    // bounds-checked navigation_index.
-    int normalized_navigation_index() const {
-      return std::max(0, std::min(current_navigation_index,
-                                  static_cast<int>(navigations.size() - 1)));
-    }
-
-    // The navigations.
-    std::vector<SerializedNavigationEntry> navigations;
-
-    // Index of the selected navigation in navigations.
-    int current_navigation_index = -1;
-
-    // The ID of the browser to which this tab belonged, so it can be restored
-    // there. May be 0 (an invalid SessionID) when restoring an entire session.
-    SessionID::id_type browser_id = 0;
-
-    // Index within the tab strip. May be -1 for an unknown index.
-    int tabstrip_index = -1;
-
-    // True if the tab was pinned.
-    bool pinned = false;
-
-    // If non-empty gives the id of the extension for the tab.
-    std::string extension_app_id;
-
-    // The associated client data.
-    std::unique_ptr<PlatformSpecificTabData> platform_data;
-
-    // The user agent override used for the tab's navigations (if applicable).
-    SerializedUserAgentOverride user_agent_override;
-
-    // The group the tab belonged to, if any.
-    std::optional<tab_groups::TabGroupId> group;
-
-    // The saved group id the tab belong to, if any.
-    std::optional<base::Uuid> saved_group_id = std::nullopt;
-
-    // The group metadata for the tab, if any.
-    std::optional<tab_groups::TabGroupVisualData> group_visual_data;
-  };
-
-  // Represents a previously open window.
-  // If you add a new field that can allocate memory, please also add
-  // it to the EstimatedMemoryUsage() implementation.
-  struct SESSIONS_EXPORT Window : public Entry {
-    Window();
-    ~Window() override;
-
-    // Entry:
-    size_t EstimateMemoryUsage() const override;
-
-    // Type of window.
-    SessionWindow::WindowType type;
-
-    // TODO(crbug.com/333425400): `tabs`, `groups`, and `tab_groups` contain
-    // duplicated data. To prevent duplication of data consider changing `tabs`
-    // to std::vector<std::unique_ptr<Entries>> so all data can be stored
-    // together in one object. This should prevent data duplication.
-    // The tabs that comprised the window, in order.
-    std::vector<std::unique_ptr<Tab>> tabs;
-
-    // Tab groups in this window including their tabs.
-    std::map<tab_groups::TabGroupId, std::unique_ptr<Group>> groups;
-
-    // Tab group data.
-    std::map<tab_groups::TabGroupId, tab_groups::TabGroupVisualData> tab_groups;
-
-    // Index of the selected tab.
-    int selected_tab_index = -1;
-
-    // If an application window, the name of the app.
-    std::string app_name;
-
-    // User-set title of the window, if there is one.
-    std::string user_title;
-
-    // Where and how the window is displayed.
-    gfx::Rect bounds;
-    ui::WindowShowState show_state;
-    std::string workspace;
-  };
-
-  // Represents a previously open group.
-  // If you add a new field that can allocate memory, please also add
-  // it to the EstimatedMemoryUsage() implementation.
-  struct SESSIONS_EXPORT Group : public Entry {
-    Group();
-    ~Group() override;
-
-    // Entry:
-    size_t EstimateMemoryUsage() const override;
-
-    // The tabs that comprised the group, in order.
-    std::vector<std::unique_ptr<Tab>> tabs;
-
-    // Group metadata.
-    tab_groups::TabGroupId group_id = tab_groups::TabGroupId::CreateEmpty();
-    tab_groups::TabGroupVisualData visual_data;
-
-    // The saved group id of this group, if any.
-    std::optional<base::Uuid> saved_group_id = std::nullopt;
-
-    // The ID of the browser to which this group belonged, so it can be restored
-    // there.
-    SessionID::id_type browser_id = 0;
-  };
-
-  typedef std::list<std::unique_ptr<Entry>> Entries;
+  typedef std::list<std::unique_ptr<tab_restore::Entry>> Entries;
   typedef base::RepeatingCallback<bool(const SerializedNavigationEntry& entry)>
       DeletionPredicate;
 
-  ~TabRestoreService() override;
+  ~TabRestoreService() override = default;
 
   // Adds/removes an observer. TabRestoreService does not take ownership of
   // the observer.
@@ -303,13 +134,6 @@ class SESSIONS_EXPORT TabRestoreService : public KeyedService {
   virtual bool IsRestoring() const = 0;
 };
 
-// A class that is used to associate platform-specific data with
-// TabRestoreService::Tab. See LiveTab::GetPlatformSpecificTabData().
-class SESSIONS_EXPORT PlatformSpecificTabData {
- public:
-  virtual ~PlatformSpecificTabData();
-};
-
 }  // namespace sessions
 
 #endif  // COMPONENTS_SESSIONS_CORE_TAB_RESTORE_SERVICE_H_

components/sessions/core/tab_restore_service_helper.cc

@@ -38,9 +38,9 @@
 #include "components/sessions/core/tab_restore_service.h"
 #include "components/sessions/core/tab_restore_service_client.h"
 #include "components/sessions/core/tab_restore_service_observer.h"
+#include "components/sessions/core/tab_restore_types.h"
 #include "components/tab_groups/tab_group_id.h"
 #include "components/tab_groups/tab_group_visual_data.h"
-
 namespace sessions {
 namespace {
 
@@ -126,7 +126,7 @@ void TabRestoreServiceHelper::Observer::OnAddEntry() {}
 TabRestoreServiceHelper::TabRestoreServiceHelper(
     TabRestoreService* tab_restore_service,
     TabRestoreServiceClient* client,
-    TabRestoreService::TimeFactory* time_factory)
+    tab_restore::TimeFactory* time_factory)
     : tab_restore_service_(tab_restore_service),
       observer_(nullptr),
       client_(client),
@@ -249,7 +249,7 @@ void TabRestoreServiceHelper::BrowserClosed(LiveTabContext* context) {
   closing_contexts_.erase(context);
 }
 
-std::unique_ptr<TabRestoreService::Group>
+std::unique_ptr<tab_restore::Group>
 TabRestoreServiceHelper::CreateHistoricalGroupImpl(
     LiveTabContext* context,
     const tab_groups::TabGroupId& id) {
@@ -394,14 +394,14 @@ void TabRestoreServiceHelper::DeleteNavigationEntries(
   Entries new_entries;
   for (std::unique_ptr<Entry>& entry : entries_) {
     switch (entry->type) {
-      case TabRestoreService::TAB: {
+      case tab_restore::Type::TAB: {
         Tab* tab = static_cast<Tab*>(entry.get());
         if (!DeleteFromTab(predicate, tab)) {
           new_entries.push_back(std::move(entry));
         }
         break;
       }
-      case TabRestoreService::WINDOW: {
+      case tab_restore::Type::WINDOW: {
         Window* window = static_cast<Window*>(entry.get());
         if (!DeleteFromWindow(predicate, window)) {
           // If only a single tab is left, just keep the tab.
@@ -413,7 +413,7 @@ void TabRestoreServiceHelper::DeleteNavigationEntries(
         }
         break;
       }
-      case TabRestoreService::GROUP: {
+      case tab_restore::Type::GROUP: {
         Group* group = static_cast<Group*>(entry.get());
         if (!DeleteFromGroup(predicate, group)) {
           new_entries.push_back(std::move(entry));
@@ -478,7 +478,7 @@ std::vector<LiveTab*> TabRestoreServiceHelper::RestoreEntryById(
   // new browser into which we restore the tabs.
   std::vector<LiveTab*> live_tabs;
   switch (entry.type) {
-    case TabRestoreService::TAB: {
+    case tab_restore::Type::TAB: {
       auto& tab = static_cast<const Tab&>(entry);
 
       if (tab.timestamp != base::Time() &&
@@ -493,7 +493,7 @@ std::vector<LiveTab*> TabRestoreServiceHelper::RestoreEntryById(
       context->ShowBrowserWindow();
       break;
     }
-    case TabRestoreService::WINDOW: {
+    case tab_restore::Type::WINDOW: {
       LiveTabContext* current_context = context;
       auto& window = static_cast<Window&>(entry);
 
@@ -624,7 +624,7 @@ std::vector<LiveTab*> TabRestoreServiceHelper::RestoreEntryById(
       }
       break;
     }
-    case TabRestoreService::GROUP: {
+    case tab_restore::Type::GROUP: {
       auto& group = static_cast<Group&>(entry);
 
       if (group.timestamp != base::Time() &&
@@ -749,14 +749,14 @@ TabRestoreServiceHelper::GetEntryIteratorById(SessionID id) {
 
     // For Window and Group entries, see if the ID matches a tab. If so, report
     // the window or group as the Entry.
-    if ((*i)->type == TabRestoreService::WINDOW) {
+    if ((*i)->type == tab_restore::Type::WINDOW) {
       const auto& window = static_cast<const Window&>(**i);
       for (const auto& tab : window.tabs) {
         if (tab->id == id || tab->original_id == id) {
           return i;
         }
       }
-    } else if ((*i)->type == TabRestoreService::GROUP) {
+    } else if ((*i)->type == tab_restore::Type::GROUP) {
       const auto& group = static_cast<const Group&>(**i);
       for (const auto& tab : group.tabs) {
         if (tab->id == id || tab->original_id == id) {
@@ -793,13 +793,13 @@ bool TabRestoreServiceHelper::OnMemoryDump(
   for (const auto& entry : entries_) {
     const char* type_string = "";
     switch (entry->type) {
-      case TabRestoreService::WINDOW:
+      case tab_restore::Type::WINDOW:
         type_string = "window";
         break;
-      case TabRestoreService::TAB:
+      case tab_restore::Type::TAB:
         type_string = "tab";
         break;
-      case TabRestoreService::GROUP:
+      case tab_restore::Type::GROUP:
         type_string = "group";
         break;
     }
@@ -828,11 +828,11 @@ bool TabRestoreServiceHelper::OnMemoryDump(
 // static
 bool TabRestoreServiceHelper::ValidateEntry(const Entry& entry) {
   switch (entry.type) {
-    case TabRestoreService::TAB:
+    case tab_restore::Type::TAB:
       return ValidateTab(static_cast<const Tab&>(entry));
-    case TabRestoreService::WINDOW:
+    case tab_restore::Type::WINDOW:
       return ValidateWindow(static_cast<const Window&>(entry));
-    case TabRestoreService::GROUP:
+    case tab_restore::Type::GROUP:
       return ValidateGroup(static_cast<const Group&>(entry));
   }
   NOTREACHED();
@@ -1017,11 +1017,11 @@ bool TabRestoreServiceHelper::FilterEntry(const Entry& entry) {
   }
 
   switch (entry.type) {
-    case TabRestoreService::TAB:
+    case tab_restore::Type::TAB:
       return IsTabInteresting(static_cast<const Tab&>(entry));
-    case TabRestoreService::WINDOW:
+    case tab_restore::Type::WINDOW:
       return IsWindowInteresting(static_cast<const Window&>(entry));
-    case TabRestoreService::GROUP:
+    case tab_restore::Type::GROUP:
       return IsGroupInteresting(static_cast<const Group&>(entry));
   }
   NOTREACHED();
@@ -1031,7 +1031,7 @@ bool TabRestoreServiceHelper::FilterEntry(const Entry& entry) {
 void TabRestoreServiceHelper::UpdateTabBrowserIDs(SessionID::id_type old_id,
                                                   SessionID new_id) {
   for (const auto& entry : entries_) {
-    if (entry->type == TabRestoreService::TAB) {
+    if (entry->type == tab_restore::Type::TAB) {
       auto& tab = static_cast<Tab&>(*entry);
       if (tab.browser_id == old_id) {
         tab.browser_id = new_id.id();

components/sessions/core/tab_restore_service_helper.h

@@ -18,6 +18,7 @@
 #include "components/sessions/core/session_types.h"
 #include "components/sessions/core/sessions_export.h"
 #include "components/sessions/core/tab_restore_service.h"
+#include "components/sessions/core/tab_restore_types.h"
 
 namespace sessions {
 
@@ -34,11 +35,11 @@ class SESSIONS_EXPORT TabRestoreServiceHelper
  public:
   typedef TabRestoreService::DeletionPredicate DeletionPredicate;
   typedef TabRestoreService::Entries Entries;
-  typedef TabRestoreService::Entry Entry;
-  typedef TabRestoreService::Tab Tab;
-  typedef TabRestoreService::TimeFactory TimeFactory;
-  typedef TabRestoreService::Window Window;
-  typedef TabRestoreService::Group Group;
+  typedef tab_restore::Entry Entry;
+  typedef tab_restore::Tab Tab;
+  typedef tab_restore::TimeFactory TimeFactory;
+  typedef tab_restore::Window Window;
+  typedef tab_restore::Group Group;
 
   // Provides a way for the client to add behavior to the tab restore service
   // helper (e.g. implementing tabs persistence).

components/sessions/core/tab_restore_service_impl.cc

@@ -129,24 +129,24 @@ const size_t kMaxEntries = TabRestoreServiceHelper::kMaxEntries;
 
 void RemoveEntryByID(
     SessionID id,
-    std::vector<std::unique_ptr<TabRestoreService::Entry>>* entries) {
+    std::vector<std::unique_ptr<tab_restore::Entry>>* entries) {
   // If the id is invalid, return.
   if (id == SessionID::InvalidValue()) {
     return;
   }  // Look for the entry in the top-level collection.
   for (auto entry_it = entries->begin(); entry_it != entries->end();
        ++entry_it) {
-    TabRestoreService::Entry& entry = **entry_it;
+    tab_restore::Entry& entry = **entry_it;
     // Erase it if it's our target.
     if (entry.id == id || entry.original_id == id) {
       entries->erase(entry_it);
       return;
     }
     // If this entry is a window, look through its tabs.
-    if (entry.type == TabRestoreService::WINDOW) {
-      auto& window = static_cast<TabRestoreService::Window&>(entry);
+    if (entry.type == tab_restore::Type::WINDOW) {
+      auto& window = static_cast<tab_restore::Window&>(entry);
       for (auto it = window.tabs.begin(); it != window.tabs.end(); ++it) {
-        const TabRestoreService::Tab& tab = **it;
+        const tab_restore::Tab& tab = **it;
         // Erase it if it's our target.
         if (tab.id == id) {
           window.tabs.erase(it);
@@ -155,10 +155,10 @@ void RemoveEntryByID(
       }
     }
     // If this entry is a group, look through its tabs.
-    if (entry.type == TabRestoreService::GROUP) {
-      auto& group = static_cast<TabRestoreService::Group&>(entry);
+    if (entry.type == tab_restore::Type::GROUP) {
+      auto& group = static_cast<tab_restore::Group&>(entry);
       for (auto it = group.tabs.begin(); it != group.tabs.end(); ++it) {
-        const TabRestoreService::Tab& tab = **it;
+        const tab_restore::Tab& tab = **it;
         // Erase it if it's our target.
         if (tab.id == id) {
           group.tabs.erase(it);
@@ -281,10 +281,10 @@ struct WindowCommandFields {
   int type = 0;
 };
 
-std::unique_ptr<sessions::TabRestoreService::Window>
-CreateWindowEntryFromCommand(const SessionCommand* command,
-                             SessionID* window_id,
-                             int32_t* num_tabs) {
+std::unique_ptr<sessions::tab_restore::Window> CreateWindowEntryFromCommand(
+    const SessionCommand* command,
+    SessionID* window_id,
+    int32_t* num_tabs) {
   WindowCommandFields fields;
   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
   auto type = sessions::SessionWindow::TYPE_NORMAL;
@@ -375,8 +375,8 @@ CreateWindowEntryFromCommand(const SessionCommand* command,
   }
 
   // Create the Window entry.
-  std::unique_ptr<sessions::TabRestoreService::Window> window =
-      std::make_unique<sessions::TabRestoreService::Window>();
+  std::unique_ptr<sessions::tab_restore::Window> window =
+      std::make_unique<sessions::tab_restore::Window>();
   window->type = type;
   window->selected_tab_index = fields.selected_tab_index;
   window->timestamp = base::Time::FromDeltaSinceWindowsEpoch(
@@ -410,7 +410,7 @@ struct GroupCommandFields {
   uint32_t color = 0;
 };
 
-std::unique_ptr<sessions::TabRestoreService::Group> CreateGroupEntryFromCommand(
+std::unique_ptr<sessions::tab_restore::Group> CreateGroupEntryFromCommand(
     const SessionCommand* command,
     SessionID* session_id,
     int32_t* num_tabs) {
@@ -436,8 +436,8 @@ std::unique_ptr<sessions::TabRestoreService::Group> CreateGroupEntryFromCommand(
   GroupCommandFields fields = parsed_fields;
 
   // Create the Group entry.
-  std::unique_ptr<sessions::TabRestoreService::Group> group =
-      std::make_unique<sessions::TabRestoreService::Group>();
+  std::unique_ptr<sessions::tab_restore::Group> group =
+      std::make_unique<sessions::tab_restore::Group>();
   group->group_id =
       tab_groups::TabGroupId::FromRawToken(fields.tab_group_token.value());
   group->browser_id = fields.browser_id;
@@ -495,22 +495,23 @@ class TabRestoreServiceImpl::PersistenceDelegate
   // Creates and add entries to |entries| for each of the windows in |windows|.
   static void CreateEntriesFromWindows(
       std::vector<std::unique_ptr<sessions::SessionWindow>>* windows,
-      std::vector<std::unique_ptr<Entry>>* entries);
+      std::vector<std::unique_ptr<tab_restore::Entry>>* entries);
 
   void Shutdown();
 
   // Schedules the commands for a window close.
-  void ScheduleCommandsForWindow(const Window& window);
+  void ScheduleCommandsForWindow(const tab_restore::Window& window);
 
   // Schedules the commands for a group close.
-  void ScheduleCommandsForGroup(const Group& group);
+  void ScheduleCommandsForGroup(const tab_restore::Group& group);
 
   // Schedules the commands for a list of tabs (from a window or group).
-  void ScheduleCommandsForTabs(const std::vector<std::unique_ptr<Tab>>& tabs);
+  void ScheduleCommandsForTabs(
+      const std::vector<std::unique_ptr<tab_restore::Tab>>& tabs);
 
   // Schedules the commands for a tab close. |selected_index| gives the index of
   // the selected navigation.
-  void ScheduleCommandsForTab(const Tab& tab, int selected_index);
+  void ScheduleCommandsForTab(const tab_restore::Tab& tab, int selected_index);
 
   void ScheduleRestoredEntryCommandsForTest(SessionID id);
 
@@ -547,7 +548,7 @@ class TabRestoreServiceImpl::PersistenceDelegate
   // |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if no
   // valid navigation to persist.
-  int GetSelectedNavigationIndexToPersist(const Tab& tab);
+  int GetSelectedNavigationIndexToPersist(const tab_restore::Tab& tab);
 
   // Invoked when we've loaded the session commands that identify the previously
   // closed tabs. This creates entries, adds them to staging_entries_, and
@@ -559,12 +560,12 @@ class TabRestoreServiceImpl::PersistenceDelegate
   // Populates |loaded_entries| with Entries from |commands|.
   void CreateEntriesFromCommands(
       const std::vector<std::unique_ptr<SessionCommand>>& commands,
-      std::vector<std::unique_ptr<Entry>>* loaded_entries);
+      std::vector<std::unique_ptr<tab_restore::Entry>>* loaded_entries);
 
   // Validates all entries in |entries|, deleting any with no navigations. This
   // also deletes any entries beyond the max number of entries we can hold.
   static void ValidateAndDeleteEmptyEntries(
-      std::vector<std::unique_ptr<Entry>>* entries);
+      std::vector<std::unique_ptr<tab_restore::Entry>>* entries);
 
   // Callback from CommandStorageManager when we've received the windows from
   // the previous session. This creates and add entries to |staging_entries_|
@@ -577,7 +578,7 @@ class TabRestoreServiceImpl::PersistenceDelegate
   // Converts a SessionWindow into a Window, returning true on success. We use 0
   // as the timestamp here since we do not know when the window/tab was closed.
   static bool ConvertSessionWindowToWindow(SessionWindow* session_window,
-                                           Window* window);
+                                           tab_restore::Window* window);
 
   // Invoked when previous tabs or session is loaded. If both have finished
   // loading the entries in |staging_entries_| are added to entries and
@@ -604,7 +605,7 @@ class TabRestoreServiceImpl::PersistenceDelegate
   // Results from previously closed tabs/sessions is first added here. When the
   // results from both us and the session restore service have finished loading
   // LoadStateChanged is invoked, which adds these entries to entries_.
-  std::vector<std::unique_ptr<Entry>> staging_entries_;
+  std::vector<std::unique_ptr<tab_restore::Entry>> staging_entries_;
 
   // Used when loading previous tabs/session and open tabs/session.
   base::WeakPtrFactory<PersistenceDelegate> weak_factory_{this};
@@ -646,21 +647,21 @@ void TabRestoreServiceImpl::PersistenceDelegate::OnWillSaveCommands() {
     DCHECK(static_cast<size_t>(to_write_count) <= entries.size());
     std::advance(i, entries.size() - static_cast<int>(to_write_count));
     for (; i != entries.rend(); ++i) {
-      Entry& entry = **i;
+      tab_restore::Entry& entry = **i;
       switch (entry.type) {
-        case TAB: {
-          Tab& tab = static_cast<Tab&>(entry);
+        case tab_restore::Type::TAB: {
+          tab_restore::Tab& tab = static_cast<tab_restore::Tab&>(entry);
           int selected_index = GetSelectedNavigationIndexToPersist(tab);
           if (selected_index != -1) {
             ScheduleCommandsForTab(tab, selected_index);
           }
           break;
         }
-        case WINDOW:
-          ScheduleCommandsForWindow(static_cast<Window&>(entry));
+        case tab_restore::Type::WINDOW:
+          ScheduleCommandsForWindow(static_cast<tab_restore::Window&>(entry));
           break;
-        case GROUP:
-          ScheduleCommandsForGroup(static_cast<Group&>(entry));
+        case tab_restore::Type::GROUP:
+          ScheduleCommandsForGroup(static_cast<tab_restore::Group&>(entry));
           break;
       }
       entries_written_++;
@@ -767,9 +768,10 @@ bool TabRestoreServiceImpl::PersistenceDelegate::IsLoaded() const {
 // static
 void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromWindows(
     std::vector<std::unique_ptr<sessions::SessionWindow>>* windows,
-    std::vector<std::unique_ptr<Entry>>* entries) {
+    std::vector<std::unique_ptr<tab_restore::Entry>>* entries) {
   for (const auto& session_window : *windows) {
-    std::unique_ptr<Window> window = std::make_unique<Window>();
+    std::unique_ptr<tab_restore::Window> window =
+        std::make_unique<tab_restore::Window>();
     if (ConvertSessionWindowToWindow(session_window.get(), window.get())) {
       entries->push_back(std::move(window));
     }
@@ -781,7 +783,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::Shutdown() {
 }
 
 void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForWindow(
-    const Window& window) {
+    const tab_restore::Window& window) {
   DCHECK(!window.tabs.empty());
   int selected_tab = window.selected_tab_index;
   int valid_tab_count = 0;
@@ -815,7 +817,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForWindow(
 }
 
 void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForGroup(
-    const Group& group) {
+    const tab_restore::Group& group) {
   DCHECK(!group.tabs.empty());
 
   command_storage_manager_->ScheduleCommand(
@@ -825,8 +827,8 @@ void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForGroup(
 }
 
 void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForTabs(
-    const std::vector<std::unique_ptr<Tab>>& tabs) {
-  for (const std::unique_ptr<Tab>& tab : tabs) {
+    const std::vector<std::unique_ptr<tab_restore::Tab>>& tabs) {
+  for (const std::unique_ptr<tab_restore::Tab>& tab : tabs) {
     int selected_index = GetSelectedNavigationIndexToPersist(*tab);
     if (selected_index != -1) {
       ScheduleCommandsForTab(*tab, selected_index);
@@ -835,7 +837,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForTabs(
 }
 
 void TabRestoreServiceImpl::PersistenceDelegate::ScheduleCommandsForTab(
-    const Tab& tab,
+    const tab_restore::Tab& tab,
     int selected_index) {
   const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int max_index = static_cast<int>(navigations.size());
@@ -996,7 +998,7 @@ TabRestoreServiceImpl::PersistenceDelegate::CreateRestoredEntryCommand(
 }
 
 int TabRestoreServiceImpl::PersistenceDelegate::
-    GetSelectedNavigationIndexToPersist(const Tab& tab) {
+    GetSelectedNavigationIndexToPersist(const tab_restore::Tab& tab) {
   const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int selected_index = tab.current_navigation_index;
   int max_index = static_cast<int>(navigations.size());
@@ -1026,7 +1028,7 @@ int TabRestoreServiceImpl::PersistenceDelegate::
 void TabRestoreServiceImpl::PersistenceDelegate::OnGotLastSessionCommands(
     std::vector<std::unique_ptr<SessionCommand>> commands,
     bool read_error) {
-  std::vector<std::unique_ptr<TabRestoreService::Entry>> entries;
+  std::vector<std::unique_ptr<tab_restore::Entry>> entries;
   CreateEntriesFromCommands(commands, &entries);
   // Closed tabs always go to the end.
   staging_entries_.insert(staging_entries_.end(),
@@ -1038,20 +1040,20 @@ void TabRestoreServiceImpl::PersistenceDelegate::OnGotLastSessionCommands(
 
 void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
     const std::vector<std::unique_ptr<SessionCommand>>& commands,
-    std::vector<std::unique_ptr<Entry>>* loaded_entries) {
+    std::vector<std::unique_ptr<tab_restore::Entry>>* loaded_entries) {
   if (tab_restore_service_helper_->entries().size() == kMaxEntries) {
     return;
   }
   // Iterate through the commands, populating |entries|.
-  std::vector<std::unique_ptr<Entry>> entries;
+  std::vector<std::unique_ptr<tab_restore::Entry>> entries;
   // If non-null we're processing the navigations of this tab.
-  Tab* current_tab = nullptr;
+  tab_restore::Tab* current_tab = nullptr;
   // If non-null we're processing the tabs of this window. The int represents
   // the number of tabs left to process within the window.
-  std::optional<std::pair<Window*, int>> current_window;
+  std::optional<std::pair<tab_restore::Window*, int>> current_window;
   // If non-null we're processing the tabs of this group. The int represents
   // the number of tabs left to process within the group.
-  std::optional<std::pair<Group*, int>> current_group;
+  std::optional<std::pair<tab_restore::Group*, int>> current_group;
   for (const auto& i : commands) {
     const SessionCommand& command = *i;
     switch (command.id()) {
@@ -1084,7 +1086,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
 
         int32_t num_tabs = 0;
         SessionID window_id = SessionID::InvalidValue();
-        std::unique_ptr<Window> window =
+        std::unique_ptr<tab_restore::Window> window =
             CreateWindowEntryFromCommand(&command, &window_id, &num_tabs);
         if (!window) {
           return;
@@ -1111,7 +1113,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
 
         int32_t num_tabs = 0;
         SessionID group_id = SessionID::InvalidValue();
-        std::unique_ptr<Group> group =
+        std::unique_ptr<tab_restore::Group> group =
             CreateGroupEntryFromCommand(&command, &group_id, &num_tabs);
         if (!group) {
           return;
@@ -1150,7 +1152,8 @@ void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
             NOTREACHED();
             return;
           }
-          current_window->first->tabs.push_back(std::make_unique<Tab>());
+          current_window->first->tabs.push_back(
+              std::make_unique<tab_restore::Tab>());
           current_tab = current_window->first->tabs.back().get();
           if (--current_window->second == 0) {
             current_window = std::nullopt;
@@ -1161,15 +1164,16 @@ void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
             NOTREACHED();
             return;
           }
-          current_group->first->tabs.push_back(std::make_unique<Tab>());
+          current_group->first->tabs.push_back(
+              std::make_unique<tab_restore::Tab>());
           current_tab = current_group->first->tabs.back().get();
           if (--current_group->second == 0) {
             current_group = std::nullopt;
           }
         } else {
           RemoveEntryByID(SessionID::FromSerializedValue(payload.id), &entries);
-          entries.push_back(std::make_unique<Tab>());
-          current_tab = static_cast<Tab*>(entries.back().get());
+          entries.push_back(std::make_unique<tab_restore::Tab>());
+          current_tab = static_cast<tab_restore::Tab*>(entries.back().get());
           current_tab->timestamp = base::Time::FromDeltaSinceWindowsEpoch(
               base::Microseconds(payload.timestamp));
         }
@@ -1346,11 +1350,11 @@ void TabRestoreServiceImpl::PersistenceDelegate::CreateEntriesFromCommands(
 
 // static
 void TabRestoreServiceImpl::PersistenceDelegate::ValidateAndDeleteEmptyEntries(
-    std::vector<std::unique_ptr<Entry>>* entries) {
-  std::vector<std::unique_ptr<Entry>> valid_entries;
+    std::vector<std::unique_ptr<tab_restore::Entry>>* entries) {
+  std::vector<std::unique_ptr<tab_restore::Entry>> valid_entries;
 
   // Iterate from the back so that we keep the most recently closed entries.
-  for (std::unique_ptr<Entry>& entry : base::Reversed(*entries)) {
+  for (std::unique_ptr<tab_restore::Entry>& entry : base::Reversed(*entries)) {
     if (TabRestoreServiceHelper::ValidateEntry(*entry)) {
       valid_entries.push_back(std::move(entry));
     }
@@ -1363,7 +1367,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::OnGotPreviousSession(
     std::vector<std::unique_ptr<SessionWindow>> windows,
     SessionID ignored_active_window,
     bool error_reading) {
-  std::vector<std::unique_ptr<Entry>> entries;
+  std::vector<std::unique_ptr<tab_restore::Entry>> entries;
   CreateEntriesFromWindows(&windows, &entries);
   // Previous session tabs go first.
   staging_entries_.insert(staging_entries_.begin(),
@@ -1375,7 +1379,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::OnGotPreviousSession(
 
 bool TabRestoreServiceImpl::PersistenceDelegate::ConvertSessionWindowToWindow(
     SessionWindow* session_window,
-    Window* window) {
+    tab_restore::Window* window) {
   window->type = session_window->type;
 
   // The group visual datas must be stored in both |window| and each
@@ -1391,8 +1395,8 @@ bool TabRestoreServiceImpl::PersistenceDelegate::ConvertSessionWindowToWindow(
     if (i->navigations.empty()) {
       continue;
     }
-    window->tabs.push_back(std::make_unique<Tab>());
-    Tab& tab = *window->tabs.back();
+    window->tabs.push_back(std::make_unique<tab_restore::Tab>());
+    tab_restore::Tab& tab = *window->tabs.back();
 
     auto group_id = i->group;
     if (group_id.has_value()) {
@@ -1480,7 +1484,7 @@ void TabRestoreServiceImpl::PersistenceDelegate::
 TabRestoreServiceImpl::TabRestoreServiceImpl(
     std::unique_ptr<TabRestoreServiceClient> client,
     PrefService* pref_service,
-    TimeFactory* time_factory)
+    tab_restore::TimeFactory* time_factory)
     : client_(std::move(client)), helper_(this, client_.get(), time_factory) {
   if (pref_service) {
     pref_change_registrar_.Init(pref_service);

components/sessions/core/tab_restore_service_impl.h

@@ -27,7 +27,7 @@ class SESSIONS_EXPORT TabRestoreServiceImpl : public TabRestoreService {
   // Does not take ownership of |time_factory|.
   TabRestoreServiceImpl(std::unique_ptr<TabRestoreServiceClient> client,
                         PrefService* pref_service,
-                        TimeFactory* time_factory);
+                        tab_restore::TimeFactory* time_factory);
 
   TabRestoreServiceImpl(const TabRestoreServiceImpl&) = delete;
   TabRestoreServiceImpl& operator=(const TabRestoreServiceImpl&) = delete;

components/sessions/core/tab_restore_types.cc

@@ -0,0 +1,51 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/sessions/core/tab_restore_types.h"
+
+#include "base/trace_event/memory_usage_estimator.h"
+
+namespace sessions::tab_restore {
+
+TimeFactory::~TimeFactory() = default;
+
+Entry::Entry(Type type)
+    : id(SessionID::NewUnique()),
+      original_id(SessionID::InvalidValue()),
+      type(type) {}
+Entry::~Entry() = default;
+
+size_t Entry::EstimateMemoryUsage() const {
+  return 0;
+}
+
+Tab::Tab() : Entry(TAB) {}
+Tab::~Tab() = default;
+
+size_t Tab::EstimateMemoryUsage() const {
+  using base::trace_event::EstimateMemoryUsage;
+  return EstimateMemoryUsage(navigations) +
+         EstimateMemoryUsage(extension_app_id) +
+         user_agent_override.EstimateMemoryUsage();
+}
+
+Window::Window() : Entry(WINDOW) {}
+Window::~Window() = default;
+
+size_t Window::EstimateMemoryUsage() const {
+  using base::trace_event::EstimateMemoryUsage;
+  return EstimateMemoryUsage(tabs) + EstimateMemoryUsage(app_name);
+}
+
+Group::Group() : Entry(GROUP) {}
+Group::~Group() = default;
+
+size_t Group::EstimateMemoryUsage() const {
+  using base::trace_event::EstimateMemoryUsage;
+  return EstimateMemoryUsage(tabs) + EstimateMemoryUsage(visual_data.title());
+}
+
+PlatformSpecificTabData::~PlatformSpecificTabData() = default;
+
+}  // namespace sessions::tab_restore

components/sessions/core/tab_restore_types.h

@@ -0,0 +1,203 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_SESSIONS_CORE_TAB_RESTORE_TYPES_H_
+#define COMPONENTS_SESSIONS_CORE_TAB_RESTORE_TYPES_H_
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "base/time/time.h"
+#include "base/uuid.h"
+#include "components/sessions/core/serialized_navigation_entry.h"
+#include "components/sessions/core/serialized_user_agent_override.h"
+#include "components/sessions/core/session_id.h"
+#include "components/sessions/core/session_types.h"
+#include "components/sessions/core/sessions_export.h"
+#include "components/tab_groups/tab_group_id.h"
+#include "components/tab_groups/tab_group_visual_data.h"
+#include "ui/gfx/geometry/rect.h"
+
+namespace sessions::tab_restore {
+
+// Interface used to allow the test to provide a custom time.
+class SESSIONS_EXPORT TimeFactory {
+ public:
+  virtual ~TimeFactory();
+  virtual base::Time TimeNow() = 0;
+};
+
+// A class that is used to associate platform-specific data with
+// TabRestoreTab. See LiveTab::GetPlatformSpecificTabData().
+class SESSIONS_EXPORT PlatformSpecificTabData {
+ public:
+  virtual ~PlatformSpecificTabData();
+};
+
+// The type of entry.
+enum Type {
+  TAB,
+  GROUP,
+  WINDOW,
+};
+
+// Represent a previously open object (a memento) that is stored in memory
+// allowing us to identify and restore specific entries using their `id` to a
+// previous state.
+struct SESSIONS_EXPORT Entry {
+  Entry(const Entry&) = delete;
+  Entry& operator=(const Entry&) = delete;
+
+  virtual ~Entry();
+
+  // Unique id for this entry. The id is guaranteed to be unique for a
+  // session.
+  SessionID id;
+
+  // The original id of the entry when it was saved.
+  SessionID original_id;
+
+  // The type of the entry.
+  const Type type;
+
+  // The time when the window, tab, or group was closed. Not always set - can
+  // be nullptr or 0 in cases where a timestamp isn't available at entry
+  // creation.
+  base::Time timestamp;
+
+  // Used for storing arbitrary key/value pairs.
+  std::map<std::string, std::string> extra_data;
+
+  // Estimates memory usage. By default returns 0.
+  virtual size_t EstimateMemoryUsage() const;
+
+ protected:
+  explicit Entry(Type type);
+};
+
+// Represents a previously open tab.
+// If you add a new field that can allocate memory also add
+// it to the EstimatedMemoryUsage() implementation.
+struct SESSIONS_EXPORT Tab : public Entry {
+  Tab();
+  ~Tab() override;
+
+  // Entry:
+  size_t EstimateMemoryUsage() const override;
+
+  // Since the current_navigation_index can be larger than the index for
+  // number of navigations in the current sessions (chrome://newtab is not
+  // stored), we must perform bounds checking. Returns a normalized
+  // bounds-checked navigation_index.
+  int normalized_navigation_index() const {
+    return std::max(0, std::min(current_navigation_index,
+                                static_cast<int>(navigations.size() - 1)));
+  }
+
+  // The navigations.
+  std::vector<sessions::SerializedNavigationEntry> navigations;
+
+  // Index of the selected navigation in navigations.
+  int current_navigation_index = -1;
+
+  // The ID of the browser to which this tab belonged, so it can be restored
+  // there. May be 0 (an invalid SessionID) when restoring an entire session.
+  SessionID::id_type browser_id = 0;
+
+  // Index within the tab strip. May be -1 for an unknown index.
+  int tabstrip_index = -1;
+
+  // True if the tab was pinned.
+  bool pinned = false;
+
+  // If non-empty gives the id of the extension for the tab.
+  std::string extension_app_id;
+
+  // The associated client data.
+  std::unique_ptr<PlatformSpecificTabData> platform_data;
+
+  // The user agent override used for the tab's navigations (if applicable).
+  sessions::SerializedUserAgentOverride user_agent_override;
+
+  // The group the tab belonged to, if any.
+  std::optional<tab_groups::TabGroupId> group;
+
+  // The saved group id the tab belong to, if any.
+  std::optional<base::Uuid> saved_group_id = std::nullopt;
+
+  // The group metadata for the tab, if any.
+  std::optional<tab_groups::TabGroupVisualData> group_visual_data;
+};
+
+// Represents a previously open group.
+// If you add a new field that can allocate memory also add
+// it to the EstimatedMemoryUsage() implementation.
+struct SESSIONS_EXPORT Group : public Entry {
+  Group();
+  ~Group() override;
+
+  // Entry:
+  size_t EstimateMemoryUsage() const override;
+
+  // The tabs that comprised the group, in order.
+  std::vector<std::unique_ptr<Tab>> tabs;
+
+  // Group metadata.
+  tab_groups::TabGroupId group_id = tab_groups::TabGroupId::CreateEmpty();
+  tab_groups::TabGroupVisualData visual_data;
+
+  // The saved group id of this group, if any.
+  std::optional<base::Uuid> saved_group_id = std::nullopt;
+
+  // The ID of the browser to which this group belonged, so it can be restored
+  // there.
+  SessionID::id_type browser_id = 0;
+};
+
+// Represents a previously open window.
+// If you add a new field that can allocate memory, please also add
+// it to the EstimatedMemoryUsage() implementation.
+struct SESSIONS_EXPORT Window : public Entry {
+  Window();
+  ~Window() override;
+
+  // Entry:
+  size_t EstimateMemoryUsage() const override;
+
+  // Type of window.
+  sessions::SessionWindow::WindowType type;
+
+  // TODO(crbug.com/333425400): `tabs`, `groups`, and `tab_groups` contain
+  // duplicated data. To prevent duplication of data consider changing `tabs`
+  // to std::vector<std::unique_ptr<Entries>> so all data can be stored
+  // together in one object. This should prevent data duplication.
+  // The tabs that comprised the window, in order.
+  std::vector<std::unique_ptr<Tab>> tabs;
+
+  // Tab groups in this window including their tabs.
+  std::map<tab_groups::TabGroupId, std::unique_ptr<Group>> groups;
+
+  // Tab group data.
+  std::map<tab_groups::TabGroupId, tab_groups::TabGroupVisualData> tab_groups;
+
+  // Index of the selected tab.
+  int selected_tab_index = -1;
+
+  // If an application window, the name of the app.
+  std::string app_name;
+
+  // User-set title of the window, if there is one.
+  std::string user_title;
+
+  // Where and how the window is displayed.
+  gfx::Rect bounds;
+  ui::WindowShowState show_state;
+  std::string workspace;
+};
+
+}  // namespace sessions::tab_restore
+
+#endif  // COMPONENTS_SESSIONS_CORE_TAB_RESTORE_TYPES_H_

docs/ui/learn/bestpractices/colors.md

@@ -640,7 +640,7 @@ class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
 
   // Adds an item for the group entry with a submenu containing its tabs.
   // Returns whether the item was successfully added.
-  bool AddGroupEntryToMenu(sessions::TabRestoreService::Group* group,
+  bool AddGroupEntryToMenu(sessions::tab_restore::Group* group,
                            NSMenu* menu,
                            NSInteger tag,
                            NSInteger index);
@@ -648,7 +648,7 @@ class HistoryMenuBridge : public sessions::TabRestoreServiceObserver,
 ...
 
 bool HistoryMenuBridge::AddGroupEntryToMenu(
-    sessions::TabRestoreService::Group* group,
+    sessions::tab_restore::Group* group,
     NSMenu* menu,
     NSInteger tag,
     NSInteger index) {

ios/chrome/browser/external_files/model/external_file_remover_impl.mm

@@ -77,8 +77,8 @@ NSSet* ComputeReferencedExternalFiles(Browser* browser) {
           browser->GetBrowserState());
   DCHECK(restore_service);
   for (const auto& entry : restore_service->entries()) {
-    sessions::TabRestoreService::Tab* tab =
-        static_cast<sessions::TabRestoreService::Tab*>(entry.get());
+    sessions::tab_restore::Tab* tab =
+        static_cast<sessions::tab_restore::Tab*>(entry.get());
     int navigation_index = tab->current_navigation_index;
     sessions::SerializedNavigationEntry navigation =
         tab->navigations[navigation_index];

ios/chrome/browser/sessions/fake_tab_restore_service.mm

@@ -8,6 +8,7 @@
 #import "base/functional/callback.h"
 #import "base/run_loop.h"
 #import "components/sessions/core/live_tab.h"
+#import "components/sessions/core/tab_restore_types.h"
 
 FakeTabRestoreService::FakeTabRestoreService() = default;
 
@@ -33,7 +34,7 @@ void FakeTabRestoreService::RemoveObserver(
 std::optional<SessionID> FakeTabRestoreService::CreateHistoricalTab(
     sessions::LiveTab* live_tab,
     int index) {
-  auto tab = std::make_unique<Tab>();
+  auto tab = std::make_unique<sessions::tab_restore::Tab>();
   int entry_count =
       live_tab->IsInitialBlankNavigation() ? 0 : live_tab->GetEntryCount();
   tab->navigations.resize(static_cast<int>(entry_count));

ios/chrome/browser/sessions/live_tab_context_browser_agent.h

@@ -69,7 +69,7 @@ class LiveTabContextBrowserAgent
       const tab_groups::TabGroupVisualData& group_visual_data,
       bool select,
       bool pin,
-      const sessions::PlatformSpecificTabData* tab_platform_data,
+      const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data,
       const SessionID* tab_id) override;
@@ -78,7 +78,7 @@ class LiveTabContextBrowserAgent
       std::optional<tab_groups::TabGroupId> group,
       int selected_navigation,
       const std::string& extension_app_id,
-      const sessions::PlatformSpecificTabData* tab_platform_data,
+      const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
       const sessions::SerializedUserAgentOverride& user_agent_override,
       const std::map<std::string, std::string>& extra_data) override;
   void CloseTab() override;

ios/chrome/browser/sessions/live_tab_context_browser_agent.mm

@@ -136,7 +136,7 @@ sessions::LiveTab* LiveTabContextBrowserAgent::AddRestoredTab(
     const tab_groups::TabGroupVisualData& group_visual_data,
     bool select,
     bool pin,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data,
     const SessionID* tab_id) {
@@ -153,7 +153,7 @@ sessions::LiveTab* LiveTabContextBrowserAgent::ReplaceRestoredTab(
     std::optional<tab_groups::TabGroupId> group,
     int selected_navigation,
     const std::string& extension_app_id,
-    const sessions::PlatformSpecificTabData* tab_platform_data,
+    const sessions::tab_restore::PlatformSpecificTabData* tab_platform_data,
     const sessions::SerializedUserAgentOverride& user_agent_override,
     const std::map<std::string, std::string>& extra_data) {
   web_state_list_->ReplaceWebStateAt(

ios/chrome/browser/tabs_search/model/tabs_search_service.mm

@@ -95,9 +95,9 @@ void TabsSearchService::SearchRecentlyClosed(
 
     // Only TAB type is handled.
     // TODO(crbug.com/1056596) : Support WINDOW restoration under multi-window.
-    DCHECK_EQ(sessions::TabRestoreService::TAB, entry->type);
-    const sessions::TabRestoreService::Tab* tab =
-        static_cast<const sessions::TabRestoreService::Tab*>(entry.get());
+    DCHECK_EQ(sessions::tab_restore::Type::TAB, entry->type);
+    const sessions::tab_restore::Tab* tab =
+        static_cast<const sessions::tab_restore::Tab*>(entry.get());
     const sessions::SerializedNavigationEntry& navigationEntry =
         tab->navigations[tab->current_navigation_index];
 

ios/chrome/browser/ui/browser_view/key_commands_provider.mm

@@ -290,11 +290,11 @@ using base::UserMetricsAction;
     return;
   }
 
-  const std::unique_ptr<sessions::TabRestoreService::Entry>& entry =
+  const std::unique_ptr<sessions::tab_restore::Entry>& entry =
       tabRestoreService->entries().front();
   // Only handle the TAB type.
   // TODO(crbug.com/1056596) : Support WINDOW restoration under multi-window.
-  if (entry->type != sessions::TabRestoreService::TAB) {
+  if (entry->type != sessions::tab_restore::Type::TAB) {
     return;
   }
 

ios/chrome/browser/ui/recent_tabs/recent_tabs_table_view_controller.mm

@@ -416,15 +416,15 @@ typedef std::pair<SessionID, TableViewURLItem*> RecentlyClosedTableViewItemPair;
     std::vector<RecentlyClosedTableViewItemPair> recentlyClosedItems;
     for (auto iter = self.tabRestoreService->entries().begin();
          iter != self.tabRestoreService->entries().end(); ++iter) {
-      const sessions::TabRestoreService::Entry* entry = iter->get();
+      const sessions::tab_restore::Entry* entry = iter->get();
       DCHECK(entry);
       // Only TAB type is handled.
       // TODO(crbug.com/1056596) : Support WINDOW restoration under
       // multi-window.
-      DCHECK_EQ(sessions::TabRestoreService::TAB, entry->type);
+      DCHECK_EQ(sessions::tab_restore::Type::TAB, entry->type);
 
-      const sessions::TabRestoreService::Tab* tab =
-          static_cast<const sessions::TabRestoreService::Tab*>(entry);
+      const sessions::tab_restore::Tab* tab =
+          static_cast<const sessions::tab_restore::Tab*>(entry);
       const sessions::SerializedNavigationEntry& navigationEntry =
           tab->navigations[tab->current_navigation_index];