OnTask: unified boca enums with ontask enums

This CL replaces the OnTaskBlockList::RestrictionLevel
enums with the ones from the boca bundle.

Bug: b:373548379
Change-Id: Ib1d8fa2334ba0e113f10e509044d49289eacf895
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5954115
Commit-Queue: Matthew Zhu <zhumatthew@google.com>
Reviewed-by: Vignesh Shenvi <vshenvi@google.com>
Cr-Commit-Position: refs/heads/main@{#1372825}

chrome/browser/ash/boca/on_task/on_task_locked_session_navigation_throttle.cc

@@ -23,7 +23,8 @@
 
 namespace ash {  // namespace
 namespace {
-using RestrictionLevel = OnTaskBlocklist::RestrictionLevel;
+
+using ::boca::LockedNavigationOptions;
 
 // Returns whether all the given query parameters are found in the URL.
 bool DoAllQueryParamsExist(const std::set<std::string>& request_params,
@@ -117,7 +118,7 @@ bool OnTaskLockedSessionNavigationThrottle::MaybeProceedForOneLevelDeep(
   }
   on_task_blocklist->MaybeSetURLRestrictionLevel(
       navigation_handle()->GetWebContents(), url,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   return true;
 }
 
@@ -227,13 +228,14 @@ OnTaskLockedSessionNavigationThrottle::CheckRestrictions() {
     // exact URL for subsequent navigations. The exact URL matching will occur
     // in `on_task_blocklist->CanPerformOneLevelNavigation()`.
     if (on_task_blocklist->current_page_restriction_level() ==
-        RestrictionLevel::kOneLevelDeepNavigation) {
+        LockedNavigationOptions::LIMITED_NAVIGATION) {
       if (!MaybeProceedForOneLevelDeep(on_task_blocklist->previous_tab(),
                                        url)) {
         return content::NavigationThrottle::CANCEL;
       }
     } else if (on_task_blocklist->current_page_restriction_level() ==
-               RestrictionLevel::kDomainAndOneLevelDeepNavigation) {
+               LockedNavigationOptions::
+                   SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION) {
       // Similar conditions as the above, but we first check if it's the same
       // domain first before checking the one level deep case since we allow
       // same domain navigations as well.
@@ -254,7 +256,8 @@ OnTaskLockedSessionNavigationThrottle::CheckRestrictions() {
         if (url.DomainIs(source_url.host())) {
           on_task_blocklist->MaybeSetURLRestrictionLevel(
               navigation_handle()->GetWebContents(), url,
-              RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+              LockedNavigationOptions::
+                  SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
         } else {
           if (!MaybeProceedForOneLevelDeep(
                   navigation_handle()->GetWebContents(), url)) {

chrome/browser/ash/boca/on_task/on_task_locked_session_window_tracker_browsertest.cc

@@ -30,6 +30,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ash::boca::OnTaskSystemWebAppManagerImpl;
+using ::boca::LockedNavigationOptions;
 using ::testing::IsNull;
 using ::testing::NotNull;
 
@@ -121,11 +122,9 @@ IN_PROC_BROWSER_TEST_F(OnTaskLockedSessionWindowTrackerBrowserTest,
 
   // Spawn two tabs for testing purposes (outside the homepage tab).
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, GURL(kTabUrl1),
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, GURL(kTabUrl1), LockedNavigationOptions::OPEN_NAVIGATION);
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, GURL(kTabUrl2),
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, GURL(kTabUrl2), LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 3);
 
   // Close all tabs and verify that the app window is closed.
@@ -155,7 +154,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskLockedSessionWindowTrackerBrowserTest,
   // Spawns a tab for testing purposes (outside the homepage tab).
   const GURL base_url(kTabUrl1);
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, base_url, OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, base_url, LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   boca_app_browser->tab_strip_model()->ActivateTabAt(1);
 
@@ -192,7 +191,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskLockedSessionWindowTrackerBrowserTest,
   // Spawns a tab for testing purposes (outside the homepage tab).
   const GURL base_url(kTabUrl1);
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, base_url, OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, base_url, LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   boca_app_browser->tab_strip_model()->ActivateTabAt(1);
 
@@ -229,7 +228,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskLockedSessionWindowTrackerBrowserTest,
   // Spawns a tab for testing purposes (outside the homepage tab).
   const GURL base_url(kTabUrl1);
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, base_url, OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, base_url, LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   boca_app_browser->tab_strip_model()->ActivateTabAt(1);
 
@@ -266,7 +265,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskLockedSessionWindowTrackerBrowserTest,
   // Spawns a tab for testing purposes (outside the homepage tab).
   const GURL base_url(kTabUrl1);
   system_web_app_manager()->CreateBackgroundTabWithUrl(
-      window_id, base_url, OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      window_id, base_url, LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   boca_app_browser->tab_strip_model()->ActivateTabAt(1);
 

chrome/browser/ash/boca/on_task/on_task_locked_session_window_tracker_unittest.cc

@@ -28,6 +28,7 @@
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
+using ::boca::LockedNavigationOptions;
 using ::testing::_;
 using ::testing::StrictMock;
 
@@ -142,45 +143,47 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest, RegisterUrlsAndRestrictionLevels) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(4), url_a,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(3), url_b,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(2), url_a_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_b_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a_subdomain2,
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 5u);
   EXPECT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(4))],
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   EXPECT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(3))],
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(2))],
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   EXPECT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(1))],
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   EXPECT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->one_level_deep_original_url().size(), 2u);
 }
 
@@ -201,10 +204,10 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_a,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->MaybeSetURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a_child,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(on_task_blocklist->child_tab_to_nav_filters().size(), 1u);
 
@@ -212,12 +215,12 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(1))],
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   EXPECT_EQ(
       on_task_blocklist
           ->child_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->one_level_deep_original_url().size(), 1u);
 }
 
@@ -239,39 +242,39 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 2u);
   ASSERT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->MaybeSetURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   NavigateAndCommitActiveTab(url_subdomain);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
 
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
 
   NavigateAndCommitActiveTab(url_with_query);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   NavigateAndCommitActiveTab(url_with_path);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
 }
 
 TEST_F(OnTaskLockedSessionWindowTrackerTest, NavigateNonParentTab) {
@@ -291,33 +294,33 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest, NavigateNonParentTab) {
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->MaybeSetURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->child_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(
       on_task_blocklist
           ->child_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(1))],
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   EXPECT_CALL(boca_window_observer_, OnActiveTabChanged(_)).Times(1);
   browser()->tab_strip_model()->ActivateTabAt(1);
   task_environment()->RunUntilIdle();
 
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
 
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url),
             policy::URLBlocklist::URLBlocklistState::URL_IN_BLOCKLIST);
@@ -339,16 +342,16 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   NavigateAndCommitActiveTab(url_subdomain);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
@@ -358,7 +361,7 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
 }
 
 TEST_F(OnTaskLockedSessionWindowTrackerTest,
@@ -376,16 +379,16 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+            LockedNavigationOptions::LIMITED_NAVIGATION);
 
   EXPECT_CALL(boca_window_observer_, OnActiveTabChanged(_)).Times(1);
   const SessionID active_tab_id = sessions::SessionTabHelper::IdForTab(
@@ -400,7 +403,7 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
   // Sanity check to make sure child tabs aren't added as parent tabs.
   EXPECT_FALSE(
       on_task_blocklist->IsParentTab(tab_strip_model->GetWebContentsAt(0)));
@@ -422,17 +425,19 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_subdomain,
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   ASSERT_EQ(on_task_blocklist->parent_tab_to_nav_filters().size(), 1u);
   ASSERT_EQ(
       on_task_blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               tab_strip_model->GetWebContentsAt(0))],
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
-  EXPECT_EQ(
-      on_task_blocklist->current_page_restriction_level(),
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
+            LockedNavigationOptions::
+                SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   NavigateAndCommitActiveTab(url);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
@@ -441,18 +446,18 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
   NavigateAndCommitActiveTab(url_redirect);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
-  EXPECT_EQ(
-      on_task_blocklist->current_page_restriction_level(),
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
+            LockedNavigationOptions::
+                SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
 
   const GURL url_redirect_not_same_domain(kTabUrlRedirectedUrl);
 
   NavigateAndCommitActiveTab(url_redirect_not_same_domain);
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
-  EXPECT_EQ(
-      on_task_blocklist->current_page_restriction_level(),
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
+            LockedNavigationOptions::
+                SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   EXPECT_CALL(boca_window_observer_, OnActiveTabChanged(_)).Times(1);
   const SessionID active_tab_id = sessions::SessionTabHelper::IdForTab(
       tab_strip_model->GetWebContentsAt(0));
@@ -466,7 +471,7 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
   browser()->tab_strip_model()->UpdateWebContentsStateAt(0,
                                                          TabChangeType::kAll);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
 }
 
 TEST_F(OnTaskLockedSessionWindowTrackerTest, SwitchTabWithNewRestrictedLevel) {
@@ -486,17 +491,17 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest, SwitchTabWithNewRestrictedLevel) {
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(1), url_a,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_b,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_CALL(boca_window_observer_, OnActiveTabChanged(_)).Times(1);
   browser()->tab_strip_model()->ActivateTabAt(1);
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
 }
 
 TEST_F(OnTaskLockedSessionWindowTrackerTest,
@@ -516,11 +521,11 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_a),
             policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_b),
@@ -549,11 +554,11 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            LockedNavigationOptions::DOMAIN_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_a_front_subdomain),
             policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_a_subpage),
@@ -585,11 +590,11 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_a_front_subdomain),
             policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(url_a_path),
@@ -619,11 +624,11 @@ TEST_F(OnTaskLockedSessionWindowTrackerTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), google_url,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            LockedNavigationOptions::DOMAIN_NAVIGATION);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(docs_url),
             policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST);
   EXPECT_EQ(on_task_blocklist->GetURLBlocklistState(random_google_url),
@@ -821,12 +826,12 @@ TEST_F(OnTaskNavigationThrottleTest, AllowUrlSuccessfullyForUnrestrictedNav) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+      LockedNavigationOptions::OPEN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kNoRestrictions);
+            LockedNavigationOptions::OPEN_NAVIGATION);
   {
     auto simulator = StartNavigation(
         url_a_front_subdomain,
@@ -874,12 +879,12 @@ TEST_F(OnTaskNavigationThrottleTest, BlockUrlSuccessfullyForRestrictedNav) {
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
   {
     auto simulator = StartNavigation(
         url_a_front_subdomain,
@@ -929,12 +934,12 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            LockedNavigationOptions::DOMAIN_NAVIGATION);
   {
     auto simulator = StartNavigation(
         url_a_front_subdomain,
@@ -981,12 +986,12 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+            LockedNavigationOptions::LIMITED_NAVIGATION);
   ASSERT_TRUE(on_task_blocklist->CanPerformOneLevelNavigation(
       tab_strip_model->GetWebContentsAt(0)));
   auto simulator = StartNavigation(
@@ -1023,12 +1028,12 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+            LockedNavigationOptions::LIMITED_NAVIGATION);
 
   // Add a new tab to the browser to simulate opening a link in a new tab
   ASSERT_TRUE(on_task_blocklist->CanPerformOneLevelNavigation(
@@ -1059,7 +1064,7 @@ TEST_F(OnTaskNavigationThrottleTest,
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            LockedNavigationOptions::BLOCK_NAVIGATION);
 
   // Attempt to navigate on this new page should fail.
   auto simulator_on_new_page = StartNavigation(
@@ -1091,13 +1096,14 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
-  ASSERT_EQ(
-      on_task_blocklist->current_page_restriction_level(),
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
+            LockedNavigationOptions::
+                SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
 
   // Same domain and one level deep works on the current page.
   ASSERT_TRUE(on_task_blocklist->CanPerformOneLevelNavigation(
@@ -1148,13 +1154,14 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+      LockedNavigationOptions::
+          SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
-  ASSERT_EQ(
-      on_task_blocklist->current_page_restriction_level(),
-      OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
+            LockedNavigationOptions::
+                SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
 
   // Add a new tab to the browser to simulate opening a link in a new tab
   ASSERT_TRUE(on_task_blocklist->CanPerformOneLevelNavigation(
@@ -1220,7 +1227,7 @@ TEST_F(OnTaskNavigationThrottleTest, ClosePopUpIfNotOauth) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       main_browser_tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   ASSERT_TRUE(window_tracker->CanOpenNewPopup());
   const std::unique_ptr<Browser> popup_browser(
@@ -1270,7 +1277,7 @@ TEST_F(OnTaskNavigationThrottleTest, OauthPopupAllowed) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       main_browser_tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   const std::unique_ptr<Browser> popup_browser(
       CreateTestBrowser(/*popup=*/true));
@@ -1319,7 +1326,7 @@ TEST_F(OnTaskNavigationThrottleTest, SuccessNavigationWorksEvenWithRedirects) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
@@ -1347,7 +1354,7 @@ TEST_F(OnTaskNavigationThrottleTest, BlockUrlInNewTabShouldClose) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
   EXPECT_CALL(boca_window_observer_, OnActiveTabChanged(_)).Times(2);
@@ -1392,12 +1399,12 @@ TEST_F(OnTaskNavigationThrottleTest, BackForwardReloadNavigationSuccess) {
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            LockedNavigationOptions::DOMAIN_NAVIGATION);
   auto simulator = StartNavigation(
       url_a_front_subdomain,
       tab_strip_model->GetWebContentsAt(0)->GetPrimaryMainFrame());
@@ -1457,12 +1464,12 @@ TEST_F(OnTaskNavigationThrottleTest,
 
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   task_environment()->RunUntilIdle();
 
   ASSERT_EQ(on_task_blocklist->current_page_restriction_level(),
-            OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+            LockedNavigationOptions::LIMITED_NAVIGATION);
   auto simulator = StartNavigation(
       url_a_front_subdomain,
       tab_strip_model->GetWebContentsAt(0)->GetPrimaryMainFrame());
@@ -1526,7 +1533,7 @@ TEST_F(OnTaskNavigationThrottleTest, BlockNavigationForPostMethodRequest) {
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+      LockedNavigationOptions::DOMAIN_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
   ASSERT_TRUE(base::test::RunUntil([&window_tracker]() {
     return window_tracker->on_task_blocklist()->GetURLBlocklistState(
@@ -1561,7 +1568,7 @@ TEST_F(OnTaskNavigationThrottleTest,
   auto* const on_task_blocklist = window_tracker->on_task_blocklist();
   on_task_blocklist->SetParentURLRestrictionLevel(
       main_browser_tab_strip_model->GetWebContentsAt(0), url_a,
-      OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation);
+      LockedNavigationOptions::LIMITED_NAVIGATION);
   window_tracker->RefreshUrlBlocklist();
 
   // Set OAuth to be in process before firing off another OAuth process within

chrome/browser/ash/boca/on_task/on_task_system_web_app_manager_impl.cc

@@ -148,7 +148,7 @@ void OnTaskSystemWebAppManagerImpl::SetWindowTrackerForSystemWebAppWindow(
 SessionID OnTaskSystemWebAppManagerImpl::CreateBackgroundTabWithUrl(
     SessionID window_id,
     GURL url,
-    OnTaskBlocklist::RestrictionLevel restriction_level) {
+    ::boca::LockedNavigationOptions::NavigationType restriction_level) {
   Browser* const browser = GetBrowserWindowWithID(window_id);
   if (!browser) {
     return SessionID::InvalidValue();

chrome/browser/ash/boca/on_task/on_task_system_web_app_manager_impl.h

@@ -41,7 +41,8 @@ class OnTaskSystemWebAppManagerImpl : public OnTaskSystemWebAppManager {
   SessionID CreateBackgroundTabWithUrl(
       SessionID window_id,
       GURL url,
-      OnTaskBlocklist::RestrictionLevel restriction_level) override;
+      ::boca::LockedNavigationOptions::NavigationType restriction_level)
+      override;
   void RemoveTabsWithTabIds(
       SessionID window_id,
       const std::set<SessionID>& tab_ids_to_remove) override;

chrome/browser/ash/boca/on_task/on_task_system_web_app_manager_impl_browsertest.cc

@@ -24,6 +24,7 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "url/gurl.h"
 
+using ::boca::LockedNavigationOptions;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::Sequence;
@@ -179,7 +180,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskSystemWebAppManagerImplBrowserTest,
   system_web_app_manager.SetWindowTrackerForTesting(&window_tracker);
   system_web_app_manager.CreateBackgroundTabWithUrl(
       boca_app_browser->session_id(), GURL(kTestUrl),
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   content::WebContents* web_contents =
       boca_app_browser->tab_strip_model()->GetWebContentsAt(1);
@@ -193,7 +194,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskSystemWebAppManagerImplBrowserTest,
       blocklist
           ->parent_tab_to_nav_filters()[sessions::SessionTabHelper::IdForTab(
               web_contents)],
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
 }
 
 IN_PROC_BROWSER_TEST_F(OnTaskSystemWebAppManagerImplBrowserTest,
@@ -223,7 +224,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskSystemWebAppManagerImplBrowserTest,
   system_web_app_manager.SetWindowTrackerForTesting(&window_tracker);
   const SessionID tab_id = system_web_app_manager.CreateBackgroundTabWithUrl(
       boca_app_browser->session_id(), GURL(kTestUrl),
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
   content::WebContents* const web_contents_1 =
       boca_app_browser->tab_strip_model()->GetWebContentsAt(1);
@@ -263,7 +264,7 @@ IN_PROC_BROWSER_TEST_F(OnTaskSystemWebAppManagerImplBrowserTest,
   // Create tab so we can verify it gets cleaned up with window prep.
   system_web_app_manager.CreateBackgroundTabWithUrl(
       boca_app_browser->session_id(), GURL(kTestUrl),
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+      LockedNavigationOptions::BLOCK_NAVIGATION);
   ASSERT_EQ(boca_app_browser->tab_strip_model()->count(), 2);
 
   // Verify that the tab is cleaned up after window prep.

chromeos/ash/components/boca/on_task/on_task_blocklist.cc

@@ -18,6 +18,9 @@
 #include "content/public/browser/web_contents.h"
 
 namespace {
+
+using ::boca::LockedNavigationOptions;
+
 constexpr char kAllTrafficWildcard[] = "*";
 
 const std::string& GetCommonUrlPrefix() {
@@ -69,7 +72,7 @@ OnTaskBlocklist::~OnTaskBlocklist() {
 policy::URLBlocklist::URLBlocklistState OnTaskBlocklist::GetURLBlocklistState(
     const GURL& url) const {
   if (current_page_restriction_level_ ==
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions) {
+      LockedNavigationOptions::OPEN_NAVIGATION) {
     return policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST;
   }
 
@@ -95,7 +98,7 @@ policy::URLBlocklist::URLBlocklistState OnTaskBlocklist::GetURLBlocklistState(
 
   if (previous_url_.is_valid() &&
       current_page_restriction_level_ ==
-          OnTaskBlocklist::RestrictionLevel::kLimitedNavigation) {
+          LockedNavigationOptions::BLOCK_NAVIGATION) {
     return previous_url_ == url
                ? policy::URLBlocklist::URLBlocklistState::URL_IN_ALLOWLIST
                : policy::URLBlocklist::URLBlocklistState::URL_IN_BLOCKLIST;
@@ -104,17 +107,17 @@ policy::URLBlocklist::URLBlocklistState OnTaskBlocklist::GetURLBlocklistState(
 }
 
 bool OnTaskBlocklist::IsCurrentRestrictionOneLevelDeep() {
-  return (
-      current_page_restriction_level_ ==
-          OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation ||
-      current_page_restriction_level_ ==
-          OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation);
+  return (current_page_restriction_level_ ==
+              LockedNavigationOptions::LIMITED_NAVIGATION ||
+          current_page_restriction_level_ ==
+              LockedNavigationOptions::
+                  SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION);
 }
 
 bool OnTaskBlocklist::MaybeSetURLRestrictionLevel(
     content::WebContents* tab,
     const GURL& url,
-    OnTaskBlocklist::RestrictionLevel restriction_level) {
+    LockedNavigationOptions::NavigationType restriction_level) {
   const SessionID tab_id = sessions::SessionTabHelper::IdForTab(tab);
   if (!tab_id.is_valid()) {
     return false;
@@ -127,10 +130,10 @@ bool OnTaskBlocklist::MaybeSetURLRestrictionLevel(
   } else {
     child_tab_to_nav_filters_[tab_id] = restriction_level;
   }
-  if (restriction_level ==
-          OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation ||
+  if (restriction_level == LockedNavigationOptions::LIMITED_NAVIGATION ||
       restriction_level ==
-          OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation) {
+          LockedNavigationOptions::
+              SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION) {
     one_level_deep_original_url_[tab_id] = url;
   }
   return true;
@@ -139,16 +142,16 @@ bool OnTaskBlocklist::MaybeSetURLRestrictionLevel(
 void OnTaskBlocklist::SetParentURLRestrictionLevel(
     content::WebContents* tab,
     const GURL& url,
-    OnTaskBlocklist::RestrictionLevel restriction_level) {
+    LockedNavigationOptions::NavigationType restriction_level) {
   const SessionID tab_id = sessions::SessionTabHelper::IdForTab(tab);
   if (!tab_id.is_valid()) {
     return;
   }
   parent_tab_to_nav_filters_[tab_id] = restriction_level;
-  if (restriction_level ==
-          OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation ||
+  if (restriction_level == LockedNavigationOptions::LIMITED_NAVIGATION ||
       restriction_level ==
-          OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation) {
+          LockedNavigationOptions::
+              SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION) {
     one_level_deep_original_url_[tab_id] = url;
   }
 }
@@ -169,7 +172,7 @@ void OnTaskBlocklist::RefreshForUrlBlocklist(content::WebContents* tab) {
   }
 
   std::unique_ptr<OnTaskBlocklistSource> blocklist_source;
-  OnTaskBlocklist::RestrictionLevel restriction_level;
+  LockedNavigationOptions::NavigationType restriction_level;
   // Updates the blocklist given the active tab's url. This function does a
   // series of checks to determine what restriction levels apply. It starts at
   // closest match starting from the child maps and continues outwards to least
@@ -191,19 +194,19 @@ void OnTaskBlocklist::RefreshForUrlBlocklist(content::WebContents* tab) {
   } else {
     // Should only happen if a url redirect opens in a new tab.
     if (current_page_restriction_level_ ==
-        OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation) {
+        LockedNavigationOptions::LIMITED_NAVIGATION) {
       blocklist_source = std::make_unique<OnTaskBlocklistSource>(
-          url, OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+          url, LockedNavigationOptions::BLOCK_NAVIGATION);
       current_page_restriction_level_ =
-          OnTaskBlocklist::RestrictionLevel::kLimitedNavigation;
+          LockedNavigationOptions::BLOCK_NAVIGATION;
     } else if (current_page_restriction_level_ ==
-               OnTaskBlocklist::RestrictionLevel::
-                   kDomainAndOneLevelDeepNavigation) {
+               LockedNavigationOptions::
+                   SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION) {
       if (!url.DomainIs(previous_url_.GetWithEmptyPath().GetContentPiece())) {
         blocklist_source = std::make_unique<OnTaskBlocklistSource>(
-            url, OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            url, LockedNavigationOptions::DOMAIN_NAVIGATION);
         current_page_restriction_level_ =
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation;
+            LockedNavigationOptions::BLOCK_NAVIGATION;
       }
     } else {
       blocklist_source = std::make_unique<OnTaskBlocklistSource>(
@@ -261,12 +264,12 @@ const policy::URLBlocklistManager* OnTaskBlocklist::url_blocklist_manager() {
   return url_blocklist_manager_.get();
 }
 
-std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+std::map<SessionID, LockedNavigationOptions::NavigationType>
 OnTaskBlocklist::parent_tab_to_nav_filters() {
   return parent_tab_to_nav_filters_;
 }
 
-std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+std::map<SessionID, LockedNavigationOptions::NavigationType>
 OnTaskBlocklist::child_tab_to_nav_filters() {
   return child_tab_to_nav_filters_;
 }
@@ -275,7 +278,7 @@ std::map<SessionID, GURL> OnTaskBlocklist::one_level_deep_original_url() {
   return one_level_deep_original_url_;
 }
 
-OnTaskBlocklist::RestrictionLevel
+LockedNavigationOptions::NavigationType
 OnTaskBlocklist::current_page_restriction_level() {
   return current_page_restriction_level_;
 }
@@ -298,18 +301,24 @@ void OnTaskBlocklist::CleanupBlocklist() {
 // OnTaskBlock::BlocklistSource Implementation
 OnTaskBlocklist::OnTaskBlocklistSource::OnTaskBlocklistSource(
     const GURL& url,
-    OnTaskBlocklist::RestrictionLevel restriction_type) {
+    LockedNavigationOptions::NavigationType restriction_type) {
   switch (restriction_type) {
-    case OnTaskBlocklist::RestrictionLevel::kDomainAndOneLevelDeepNavigation:
-    case OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation:
-    case OnTaskBlocklist::RestrictionLevel::kNoRestrictions:
+    case LockedNavigationOptions::
+        SAME_DOMAIN_OPEN_OTHER_DOMAIN_LIMITED_NAVIGATION:
+    case LockedNavigationOptions::LIMITED_NAVIGATION:
+    case LockedNavigationOptions::OPEN_NAVIGATION:
       allowlist_ = GetAllTrafficFilter();
       return;
-    case OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation:
+    case LockedNavigationOptions::DOMAIN_NAVIGATION:
       blocklist_ = GetAllTrafficFilter();
       allowlist_ = GetDomainLevelTrafficFilter(url);
       return;
-    case OnTaskBlocklist::RestrictionLevel::kLimitedNavigation:
+    case LockedNavigationOptions::NAVIGATION_TYPE_UNKNOWN:
+    case LockedNavigationOptions::BLOCK_NAVIGATION:
+      blocklist_ = GetAllTrafficFilter();
+      allowlist_ = GetLimitedTrafficFilter(url);
+      return;
+    default:
       blocklist_ = GetAllTrafficFilter();
       allowlist_ = GetLimitedTrafficFilter(url);
       return;

chromeos/ash/components/boca/on_task/on_task_blocklist.h

@@ -10,6 +10,7 @@
 
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
+#include "chromeos/ash/components/boca/proto/bundle.pb.h"
 #include "components/policy/core/browser/url_blocklist_manager.h"
 #include "components/sessions/core/session_id.h"
 #include "content/public/browser/web_contents.h"
@@ -19,15 +20,6 @@
 // restrictions for each tab.
 class OnTaskBlocklist {
  public:
-  enum class RestrictionLevel {
-    kNoRestrictions = 1,               // No url restrictions.
-    kLimitedNavigation,                // Only allow exact URL match.
-    kSameDomainNavigation,             // Allow domain/subdomain navigation.
-    kOneLevelDeepNavigation,           // Allow one level deeper navigation.
-    kDomainAndOneLevelDeepNavigation,  // Allows same domain traversal and one
-                                       // level deep.
-  };
-
   // BlocklistSource implementation that blocks all traffic with the
   // exception of URLs specified by the teacher's navigation restriction level.
   // Note that this implementation only supports one observer at a time. Adding
@@ -35,8 +27,9 @@ class OnTaskBlocklist {
   // from the main thread.
   class OnTaskBlocklistSource : public policy::BlocklistSource {
    public:
-    OnTaskBlocklistSource(const GURL& url,
-                          OnTaskBlocklist::RestrictionLevel restriction_type);
+    OnTaskBlocklistSource(
+        const GURL& url,
+        ::boca::LockedNavigationOptions::NavigationType restriction_type);
     OnTaskBlocklistSource(const OnTaskBlocklistSource&) = delete;
     OnTaskBlocklistSource& operator=(const OnTaskBlocklistSource&) = delete;
     ~OnTaskBlocklistSource() override = default;
@@ -68,14 +61,14 @@ class OnTaskBlocklist {
   bool MaybeSetURLRestrictionLevel(
       content::WebContents* tab,
       const GURL& url,
-      OnTaskBlocklist::RestrictionLevel restriction_level);
+      ::boca::LockedNavigationOptions::NavigationType restriction_level);
 
   // Sets the url restrictions for the given `url` with `restriction_level`.
   // Should only be called for the set of urls sent by the boca producer.
   void SetParentURLRestrictionLevel(
       content::WebContents* tab,
       const GURL& url,
-      OnTaskBlocklist::RestrictionLevel restriction_level);
+      ::boca::LockedNavigationOptions::NavigationType restriction_level);
 
   // Updates the blocklist that is associated with the given `tab`. This is
   // triggered on an active tab change or when the current tab changes.
@@ -107,22 +100,24 @@ class OnTaskBlocklist {
   content::WebContents* previous_tab();
 
   const policy::URLBlocklistManager* url_blocklist_manager();
-  std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+  std::map<SessionID, ::boca::LockedNavigationOptions::NavigationType>
   parent_tab_to_nav_filters();
-  std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+  std::map<SessionID, ::boca::LockedNavigationOptions::NavigationType>
   child_tab_to_nav_filters();
   std::map<SessionID, GURL> one_level_deep_original_url();
-  OnTaskBlocklist::RestrictionLevel current_page_restriction_level();
+  ::boca::LockedNavigationOptions::NavigationType
+  current_page_restriction_level();
 
  private:
-  OnTaskBlocklist::RestrictionLevel current_page_restriction_level_ =
-      OnTaskBlocklist::RestrictionLevel::kNoRestrictions;
+  ::boca::LockedNavigationOptions::NavigationType
+      current_page_restriction_level_ =
+          ::boca::LockedNavigationOptions::OPEN_NAVIGATION;
   base::WeakPtr<content::WebContents> previous_tab_;
   GURL previous_url_;
   bool first_time_popup_ = true;
-  std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+  std::map<SessionID, ::boca::LockedNavigationOptions::NavigationType>
       parent_tab_to_nav_filters_;
-  std::map<SessionID, OnTaskBlocklist::RestrictionLevel>
+  std::map<SessionID, ::boca::LockedNavigationOptions::NavigationType>
       child_tab_to_nav_filters_;
   std::map<SessionID, GURL> one_level_deep_original_url_;
   const std::unique_ptr<policy::URLBlocklistManager> url_blocklist_manager_;

chromeos/ash/components/boca/on_task/on_task_session_manager.cc

@@ -33,22 +33,6 @@ constexpr base::TimeDelta kRemoveTabRetryDelay = base::Seconds(3);
 // Delay in seconds before we attempt to pin or unpin the active SWA window.
 constexpr base::TimeDelta kSetPinnedStateDelay = base::Seconds(3);
 
-OnTaskBlocklist::RestrictionLevel NavigationTypeToRestrictionLevel(
-    ::boca::LockedNavigationOptions::NavigationType navigation_type) {
-  switch (navigation_type) {
-    case ::boca::LockedNavigationOptions::OPEN_NAVIGATION:
-      return OnTaskBlocklist::RestrictionLevel::kNoRestrictions;
-    case ::boca::LockedNavigationOptions::BLOCK_NAVIGATION:
-      return OnTaskBlocklist::RestrictionLevel::kLimitedNavigation;
-    case ::boca::LockedNavigationOptions::DOMAIN_NAVIGATION:
-      return OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation;
-    case ::boca::LockedNavigationOptions::LIMITED_NAVIGATION:
-      return OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation;
-    default:
-      return OnTaskBlocklist::RestrictionLevel::kNoRestrictions;
-  }
-}
-
 }  // namespace
 
 OnTaskSessionManager::OnTaskSessionManager(
@@ -118,13 +102,13 @@ void OnTaskSessionManager::OnBundleUpdated(const ::boca::Bundle& bundle) {
     const GURL url(content_config.url());
     current_urls_set.insert(url);
 
-    OnTaskBlocklist::RestrictionLevel restriction_level;
+    ::boca::LockedNavigationOptions::NavigationType restriction_level;
     if (content_config.has_locked_navigation_options()) {
       ::boca::LockedNavigationOptions_NavigationType navigation_type =
           content_config.locked_navigation_options().navigation_type();
-      restriction_level = NavigationTypeToRestrictionLevel(navigation_type);
+      restriction_level = navigation_type;
     } else {
-      restriction_level = OnTaskBlocklist::RestrictionLevel::kNoRestrictions;
+      restriction_level = ::boca::LockedNavigationOptions::OPEN_NAVIGATION;
     }
 
     // No need to add the tab if the tab is already tracked as opened in the
@@ -187,8 +171,9 @@ void OnTaskSessionManager::OnAppReloaded() {
   // clear stale tab ids that were tracked with the previous instance.
   for (auto& [provider_sent_url, tab_ids] : provider_url_tab_ids_map_) {
     tab_ids.clear();
-    OnTaskBlocklist::RestrictionLevel restriction_level = OnTaskBlocklist::
-        RestrictionLevel::kSameDomainNavigation;  // Default restriction.
+    ::boca::LockedNavigationOptions::NavigationType restriction_level =
+        ::boca::LockedNavigationOptions::DOMAIN_NAVIGATION;  // Default
+                                                             // restriction.
     if (provider_url_restriction_level_map_.contains(provider_sent_url)) {
       restriction_level =
           provider_url_restriction_level_map_[provider_sent_url];
@@ -253,7 +238,7 @@ void OnTaskSessionManager::SystemWebAppLaunchHelper::LaunchBocaSWA() {
 
 void OnTaskSessionManager::SystemWebAppLaunchHelper::AddTab(
     GURL url,
-    OnTaskBlocklist::RestrictionLevel restriction_level,
+    ::boca::LockedNavigationOptions::NavigationType restriction_level,
     base::OnceCallback<void(SessionID)> callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (launch_in_progress_) {
@@ -339,7 +324,7 @@ void OnTaskSessionManager::SystemWebAppLaunchHelper::OnBocaSWALaunched(
 
 void OnTaskSessionManager::OnBundleTabAdded(
     GURL url,
-    OnTaskBlocklist::RestrictionLevel restriction_level,
+    ::boca::LockedNavigationOptions::NavigationType restriction_level,
     SessionID tab_id) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (tab_id.is_valid()) {

chromeos/ash/components/boca/on_task/on_task_session_manager.h

@@ -69,9 +69,10 @@ class OnTaskSessionManager : public boca::BocaSessionManager::Observer,
     ~SystemWebAppLaunchHelper();
 
     void LaunchBocaSWA();
-    void AddTab(GURL url,
-                OnTaskBlocklist::RestrictionLevel restriction_level,
-                base::OnceCallback<void(SessionID)> callback);
+    void AddTab(
+        GURL url,
+        ::boca::LockedNavigationOptions::NavigationType restriction_level,
+        base::OnceCallback<void(SessionID)> callback);
     void RemoveTab(const std::set<SessionID>& tab_ids_to_remove,
                    base::OnceClosure callback);
     void SetPinStateForActiveSWAWindow(bool pinned, base::OnceClosure callback);
@@ -94,9 +95,10 @@ class OnTaskSessionManager : public boca::BocaSessionManager::Observer,
   };
 
   // Callback triggered when a tab from the bundle is added.
-  void OnBundleTabAdded(GURL url,
-                        OnTaskBlocklist::RestrictionLevel restriction_level,
-                        SessionID tab_id);
+  void OnBundleTabAdded(
+      GURL url,
+      ::boca::LockedNavigationOptions::NavigationType restriction_level,
+      SessionID tab_id);
 
   // Callback triggered when a tab from the bundle is removed.
   void OnBundleTabRemoved(GURL url);
@@ -117,7 +119,7 @@ class OnTaskSessionManager : public boca::BocaSessionManager::Observer,
 
   // Maps the url that providers send to the restriction levels it is currently
   // set to. This map allows for tracking restriction level updates.
-  base::flat_map<GURL, OnTaskBlocklist::RestrictionLevel>
+  base::flat_map<GURL, ::boca::LockedNavigationOptions::NavigationType>
       provider_url_restriction_level_map_ GUARDED_BY_CONTEXT(sequence_checker_);
 
   const std::unique_ptr<OnTaskExtensionsManager> extensions_manager_;

chromeos/ash/components/boca/on_task/on_task_session_manager_unittest.cc

@@ -58,12 +58,13 @@ class OnTaskSystemWebAppManagerMock : public OnTaskSystemWebAppManager {
               (SessionID window_id,
                const std::vector<boca::BocaWindowObserver*> observers),
               (override));
-  MOCK_METHOD(SessionID,
-              CreateBackgroundTabWithUrl,
-              (SessionID window_id,
-               GURL url,
-               OnTaskBlocklist::RestrictionLevel restriction_level),
-              (override));
+  MOCK_METHOD(
+      SessionID,
+      CreateBackgroundTabWithUrl,
+      (SessionID window_id,
+       GURL url,
+       ::boca::LockedNavigationOptions::NavigationType restriction_level),
+      (override));
   MOCK_METHOD(void,
               RemoveTabsWithTabIds,
               (SessionID window_id,
@@ -105,7 +106,7 @@ class OnTaskSessionManagerTest : public ::testing::Test {
     return &session_manager_->provider_url_tab_ids_map_;
   }
 
-  base::flat_map<GURL, OnTaskBlocklist::RestrictionLevel>*
+  base::flat_map<GURL, ::boca::LockedNavigationOptions::NavigationType>*
   provider_url_restriction_level_map() {
     DCHECK_CALLED_ON_VALID_SEQUENCE(session_manager_->sequence_checker_);
     return &session_manager_->provider_url_restriction_level_map_;
@@ -256,27 +257,27 @@ TEST_F(OnTaskSessionManagerTest, ShouldApplyRestrictionsToTabsOnBundleUpdated) {
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl1),
-                  OnTaskBlocklist::RestrictionLevel::kNoRestrictions))
+                  ::boca::LockedNavigationOptions::OPEN_NAVIGATION))
       .WillOnce(Return(kTabId_1));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl2),
-                  OnTaskBlocklist::RestrictionLevel::kLimitedNavigation))
+                  ::boca::LockedNavigationOptions::BLOCK_NAVIGATION))
       .WillOnce(Return(kTabId_2));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl3),
-                  OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation))
+                  ::boca::LockedNavigationOptions::DOMAIN_NAVIGATION))
       .WillOnce(Return(kTabId_3));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl4),
-                  OnTaskBlocklist::RestrictionLevel::kOneLevelDeepNavigation))
+                  ::boca::LockedNavigationOptions::LIMITED_NAVIGATION))
       .WillOnce(Return(kTabId_4));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl5),
-                  OnTaskBlocklist::RestrictionLevel::kNoRestrictions))
+                  ::boca::LockedNavigationOptions::OPEN_NAVIGATION))
       .WillOnce(Return(kTabId_5));
 
   ::boca::Bundle bundle;
@@ -491,7 +492,7 @@ TEST_F(OnTaskSessionManagerTest, ShouldUpdateRestrictionsToTabOnBundleUpdated) {
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl1),
-                  OnTaskBlocklist::RestrictionLevel::kNoRestrictions))
+                  ::boca::LockedNavigationOptions::OPEN_NAVIGATION))
       .WillOnce(Return(kTabId_1));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               RemoveTabsWithTabIds(kWindowId, std::set<SessionID>{kTabId_1}))
@@ -500,7 +501,7 @@ TEST_F(OnTaskSessionManagerTest, ShouldUpdateRestrictionsToTabOnBundleUpdated) {
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl1),
-                  OnTaskBlocklist::RestrictionLevel::kLimitedNavigation))
+                  ::boca::LockedNavigationOptions::BLOCK_NAVIGATION))
       .InSequence(s)
       .WillOnce(Return(kTabId_1));
   ::boca::Bundle bundle;
@@ -532,13 +533,13 @@ TEST_F(OnTaskSessionManagerTest, OnAppReloadWithNoActiveWindow) {
 TEST_F(OnTaskSessionManagerTest, RestoreTabsOnAppReload) {
   // Inject tab ids and nav restrictions tracked by the previous session for
   // testing purposes. It should fall back to
-  // `OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation` if there is no
-  // nav restriction being tracked.
+  // `::boca::LockedNavigationOptions::DOMAIN_NAVIGATION` if
+  // there is no nav restriction being tracked.
   const SessionID kOldTabId1 = SessionID::NewUnique();
   const SessionID kOldTabId2 = SessionID::NewUnique();
   (*provider_url_tab_ids_map())[GURL(kTestUrl1)].insert(kOldTabId1);
   (*provider_url_restriction_level_map())[GURL(kTestUrl1)] =
-      OnTaskBlocklist::RestrictionLevel::kLimitedNavigation;
+      ::boca::LockedNavigationOptions::BLOCK_NAVIGATION;
   (*provider_url_tab_ids_map())[GURL(kTestUrl2)].insert(kOldTabId2);
 
   // Attempt an app reload and verify tabs are restored with newer tab ids.
@@ -562,13 +563,13 @@ TEST_F(OnTaskSessionManagerTest, RestoreTabsOnAppReload) {
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl1),
-                  OnTaskBlocklist::RestrictionLevel::kLimitedNavigation))
+                  ::boca::LockedNavigationOptions::BLOCK_NAVIGATION))
       .InSequence(s)
       .WillOnce(Return(kTabId1));
   EXPECT_CALL(*system_web_app_manager_ptr_,
               CreateBackgroundTabWithUrl(
                   kWindowId, GURL(kTestUrl2),
-                  OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation))
+                  ::boca::LockedNavigationOptions::DOMAIN_NAVIGATION))
       .InSequence(s)
       .WillOnce(Return(kTabId2));
   session_manager_->OnAppReloaded();
@@ -577,11 +578,11 @@ TEST_F(OnTaskSessionManagerTest, RestoreTabsOnAppReload) {
   EXPECT_THAT((*provider_url_tab_ids_map())[GURL(kTestUrl1)],
               ElementsAre(kTabId1));
   EXPECT_EQ((*provider_url_restriction_level_map())[GURL(kTestUrl1)],
-            OnTaskBlocklist::RestrictionLevel::kLimitedNavigation);
+            ::boca::LockedNavigationOptions::BLOCK_NAVIGATION);
   EXPECT_THAT((*provider_url_tab_ids_map())[GURL(kTestUrl2)],
               ElementsAre(kTabId2));
   EXPECT_EQ((*provider_url_restriction_level_map())[GURL(kTestUrl2)],
-            OnTaskBlocklist::RestrictionLevel::kSameDomainNavigation);
+            ::boca::LockedNavigationOptions::DOMAIN_NAVIGATION);
 }
 
 TEST_F(OnTaskSessionManagerTest,

chromeos/ash/components/boca/on_task/on_task_system_web_app_manager.h

@@ -49,7 +49,7 @@ class OnTaskSystemWebAppManager {
   virtual SessionID CreateBackgroundTabWithUrl(
       SessionID window_id,
       GURL url,
-      OnTaskBlocklist::RestrictionLevel restriction_level) = 0;
+      ::boca::LockedNavigationOptions::NavigationType restriction_level) = 0;
 
   // Removes tabs with the given tab ids in the specified Boca SWA window.
   virtual void RemoveTabsWithTabIds(