diff --git a/chrome/browser/prefs/incognito_mode_prefs.cc b/chrome/browser/prefs/incognito_mode_prefs.cc
index 7e4b25dd..07280df8 100644
--- a/chrome/browser/prefs/incognito_mode_prefs.cc
+++ b/chrome/browser/prefs/incognito_mode_prefs.cc
@@ -36,7 +36,7 @@
 // static
 bool IncognitoModePrefs::IntToAvailability(int in_value,
                                            Availability* out_value) {
-  if (in_value < 0 || in_value >= AVAILABILITY_NUM_TYPES) {
+  if (in_value < 0 || in_value >= static_cast<int>(Availability::kNumTypes)) {
     *out_value = kDefaultAvailability;
     return false;
   }
@@ -53,14 +53,15 @@
 // static
 void IncognitoModePrefs::SetAvailability(PrefService* prefs,
                                          const Availability availability) {
-  prefs->SetInteger(prefs::kIncognitoModeAvailability, availability);
+  prefs->SetInteger(prefs::kIncognitoModeAvailability,
+                    static_cast<int>(availability));
 }
 
 // static
 void IncognitoModePrefs::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(prefs::kIncognitoModeAvailability,
-                                kDefaultAvailability);
+                                static_cast<int>(kDefaultAvailability));
 }
 
 // static
@@ -74,7 +75,7 @@
   bool should_use_incognito =
       command_line.HasSwitch(switches::kIncognito) ||
       GetAvailabilityInternal(prefs, DONT_CHECK_PARENTAL_CONTROLS) ==
-          IncognitoModePrefs::FORCED;
+          IncognitoModePrefs::Availability::kForced;
 #if BUILDFLAG(IS_CHROMEOS_LACROS)
   auto* init_params = chromeos::LacrosService::Get()->init_params();
   // TODO(https://crbug.com/1194304): Remove in M93.
@@ -85,19 +86,19 @@
 #endif
   return should_use_incognito &&
          GetAvailabilityInternal(prefs, CHECK_PARENTAL_CONTROLS) !=
-             IncognitoModePrefs::DISABLED;
+             IncognitoModePrefs::Availability::kDisabled;
 }
 
 // static
 bool IncognitoModePrefs::CanOpenBrowser(Profile* profile) {
   switch (GetAvailability(profile->GetPrefs())) {
-    case IncognitoModePrefs::ENABLED:
+    case IncognitoModePrefs::Availability::kEnabled:
       return true;
 
-    case IncognitoModePrefs::DISABLED:
+    case IncognitoModePrefs::Availability::kDisabled:
       return !profile->IsIncognitoProfile();
 
-    case IncognitoModePrefs::FORCED:
+    case IncognitoModePrefs::Availability::kForced:
       return profile->IsIncognitoProfile();
 
     default:
@@ -126,11 +127,11 @@
   Availability result = kDefaultAvailability;
   bool valid = IntToAvailability(pref_value, &result);
   DCHECK(valid);
-  if (result != IncognitoModePrefs::DISABLED &&
+  if (result != IncognitoModePrefs::Availability::kDisabled &&
       mode == CHECK_PARENTAL_CONTROLS && ArePlatformParentalControlsEnabled()) {
-    if (result == IncognitoModePrefs::FORCED)
+    if (result == IncognitoModePrefs::Availability::kForced)
       LOG(ERROR) << "Ignoring FORCED incognito. Parental control logging on";
-    return IncognitoModePrefs::DISABLED;
+    return IncognitoModePrefs::Availability::kDisabled;
   }
   return result;
 }
diff --git a/chrome/browser/prefs/incognito_mode_prefs.h b/chrome/browser/prefs/incognito_mode_prefs.h
index b80d295..50123c0 100644
--- a/chrome/browser/prefs/incognito_mode_prefs.h
+++ b/chrome/browser/prefs/incognito_mode_prefs.h
@@ -24,21 +24,21 @@
  public:
   // Possible values for Incognito mode availability. Please, do not change
   // the order of entries since numeric values are exposed to users.
-  enum Availability {
+  enum class Availability {
     // Incognito mode enabled. Users may open pages in both Incognito mode and
     // normal mode (usually the default behaviour).
-    ENABLED = 0,
+    kEnabled = 0,
     // Incognito mode disabled. Users may not open pages in Incognito mode.
     // Only normal mode is available for browsing.
-    DISABLED,
+    kDisabled,
     // Incognito mode forced. Users may open pages *ONLY* in Incognito mode.
     // Normal mode is not available for browsing.
-    FORCED,
+    kForced,
 
-    AVAILABILITY_NUM_TYPES
+    kNumTypes
   };
 
-  static constexpr Availability kDefaultAvailability = ENABLED;
+  static constexpr Availability kDefaultAvailability = Availability::kEnabled;
 
   // Register incognito related preferences.
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
diff --git a/chrome/browser/prefs/incognito_mode_prefs_unittest.cc b/chrome/browser/prefs/incognito_mode_prefs_unittest.cc
index 0fe41ca..266c9a4 100644
--- a/chrome/browser/prefs/incognito_mode_prefs_unittest.cc
+++ b/chrome/browser/prefs/incognito_mode_prefs_unittest.cc
@@ -19,17 +19,17 @@
 };
 
 TEST_F(IncognitoModePrefsTest, IntToAvailability) {
-  ASSERT_EQ(0, IncognitoModePrefs::ENABLED);
-  ASSERT_EQ(1, IncognitoModePrefs::DISABLED);
-  ASSERT_EQ(2, IncognitoModePrefs::FORCED);
+  ASSERT_EQ(0, static_cast<int>(IncognitoModePrefs::Availability::kEnabled));
+  ASSERT_EQ(1, static_cast<int>(IncognitoModePrefs::Availability::kDisabled));
+  ASSERT_EQ(2, static_cast<int>(IncognitoModePrefs::Availability::kForced));
 
   IncognitoModePrefs::Availability incognito;
   EXPECT_TRUE(IncognitoModePrefs::IntToAvailability(0, &incognito));
-  EXPECT_EQ(IncognitoModePrefs::ENABLED, incognito);
+  EXPECT_EQ(IncognitoModePrefs::Availability::kEnabled, incognito);
   EXPECT_TRUE(IncognitoModePrefs::IntToAvailability(1, &incognito));
-  EXPECT_EQ(IncognitoModePrefs::DISABLED, incognito);
+  EXPECT_EQ(IncognitoModePrefs::Availability::kDisabled, incognito);
   EXPECT_TRUE(IncognitoModePrefs::IntToAvailability(2, &incognito));
-  EXPECT_EQ(IncognitoModePrefs::FORCED, incognito);
+  EXPECT_EQ(IncognitoModePrefs::Availability::kForced, incognito);
 
   EXPECT_FALSE(IncognitoModePrefs::IntToAvailability(10, &incognito));
   EXPECT_EQ(IncognitoModePrefs::kDefaultAvailability, incognito);
@@ -38,21 +38,22 @@
 }
 
 TEST_F(IncognitoModePrefsTest, GetAvailability) {
-  prefs_.SetUserPref(
-      prefs::kIncognitoModeAvailability,
-      std::make_unique<base::Value>(IncognitoModePrefs::ENABLED));
-  EXPECT_EQ(IncognitoModePrefs::ENABLED,
-            IncognitoModePrefs::GetAvailability(&prefs_));
-
-  prefs_.SetUserPref(
-      prefs::kIncognitoModeAvailability,
-      std::make_unique<base::Value>(IncognitoModePrefs::DISABLED));
-  EXPECT_EQ(IncognitoModePrefs::DISABLED,
+  prefs_.SetUserPref(prefs::kIncognitoModeAvailability,
+                     std::make_unique<base::Value>(static_cast<int>(
+                         IncognitoModePrefs::Availability::kEnabled)));
+  EXPECT_EQ(IncognitoModePrefs::Availability::kEnabled,
             IncognitoModePrefs::GetAvailability(&prefs_));
 
   prefs_.SetUserPref(prefs::kIncognitoModeAvailability,
-                     std::make_unique<base::Value>(IncognitoModePrefs::FORCED));
-  EXPECT_EQ(IncognitoModePrefs::FORCED,
+                     std::make_unique<base::Value>(static_cast<int>(
+                         IncognitoModePrefs::Availability::kDisabled)));
+  EXPECT_EQ(IncognitoModePrefs::Availability::kDisabled,
+            IncognitoModePrefs::GetAvailability(&prefs_));
+
+  prefs_.SetUserPref(prefs::kIncognitoModeAvailability,
+                     std::make_unique<base::Value>(static_cast<int>(
+                         IncognitoModePrefs::Availability::kForced)));
+  EXPECT_EQ(IncognitoModePrefs::Availability::kForced,
             IncognitoModePrefs::GetAvailability(&prefs_));
 }
 
@@ -64,6 +65,6 @@
   EXPECT_DCHECK_DEATH({
     IncognitoModePrefs::Availability availability =
         IncognitoModePrefs::GetAvailability(&prefs_);
-    EXPECT_EQ(IncognitoModePrefs::ENABLED, availability);
+    EXPECT_EQ(IncognitoModePrefs::Availability::kEnabled, availability);
   });
 }
diff --git a/chrome/browser/prefs/tracked/pref_hash_browsertest.cc b/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
index 7c19a7b..72ea1ac 100644
--- a/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
+++ b/chrome/browser/prefs/tracked/pref_hash_browsertest.cc
@@ -364,12 +364,12 @@
         EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM,
                   num_tracked_prefs_ > 0);
 
-        int num_split_tracked_prefs = GetTrackedPrefHistogramCount(
+        int split_tracked_prefs = GetTrackedPrefHistogramCount(
             user_prefs::tracked::kTrackedPrefHistogramUnchanged,
             user_prefs::tracked::kTrackedPrefRegistryValidationSuffix,
             BEGIN_ALLOW_SINGLE_BUCKET + 5);
         EXPECT_EQ(protection_level_ > PROTECTION_DISABLED_ON_PLATFORM ? 1 : 0,
-                  num_split_tracked_prefs);
+                  split_tracked_prefs);
       }
 
       num_tracked_prefs_ += num_split_tracked_prefs;