Manage the visibility of accessibility features on accessibility tray menu

This CL will manage the visibility of all of the following accessiblity
features:
- Autoclick
- Caret highlight
- Focus highlight
- Full screen magnifier
- Docked magnifier
- Spoken feedback
- Select to speak
- Switch access
- Sticky keys
- Virtual keyboard
Show any of these accessibility features only if one of the following
conditions have meet :
-Its not being controlled by any policy
-Its being controlled by a policy and the value of the policy is force on

Bug: 552439
Change-Id: I0ea0e6165270f5de00c51ecbe4047e9243ca130f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1738374
Commit-Queue: Amr Aboelkher <amraboelkher@google.com>
Reviewed-by: Alice Boxhall <aboxhall@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#689132}

ash/accessibility/accessibility_controller_impl.cc

@@ -453,6 +453,11 @@ void AccessibilityControllerImpl::SetAutoclickEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsAutoclickSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityAutoclickEnabled);
+}
+
 void AccessibilityControllerImpl::SetCaretHighlightEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -461,6 +466,11 @@ void AccessibilityControllerImpl::SetCaretHighlightEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsCaretHighlightSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityCaretHighlightEnabled);
+}
+
 void AccessibilityControllerImpl::SetCursorHighlightEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -469,7 +479,7 @@ void AccessibilityControllerImpl::SetCursorHighlightEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
-bool AccessibilityControllerImpl::GetTrayVisiblityOfCursorHighlightSetting() {
+bool AccessibilityControllerImpl::IsCursorHighlightSettingVisibleInTray() {
   return IsAccessibilityFeatureVisibleInTrayMenu(
       prefs::kAccessibilityCursorHighlightEnabled);
 }
@@ -499,7 +509,7 @@ void AccessibilityControllerImpl::SetDictationEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
-bool AccessibilityControllerImpl::GetTrayVisiblityOfDictationSetting() {
+bool AccessibilityControllerImpl::IsDictationSettingVisibleInTray() {
   return IsAccessibilityFeatureVisibleInTrayMenu(
       prefs::kAccessibilityDictationEnabled);
 }
@@ -512,6 +522,11 @@ void AccessibilityControllerImpl::SetFocusHighlightEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsFocusHighlightSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityFocusHighlightEnabled);
+}
+
 void AccessibilityControllerImpl::SetFullscreenMagnifierEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -520,6 +535,34 @@ void AccessibilityControllerImpl::SetFullscreenMagnifierEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsFullscreenMagnifierEnabledForTesting() {
+  return active_user_prefs_ && active_user_prefs_->GetBoolean(
+                                   prefs::kAccessibilityScreenMagnifierEnabled);
+}
+
+bool AccessibilityControllerImpl::IsFullScreenMagnifierSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityScreenMagnifierEnabled);
+}
+
+void AccessibilityControllerImpl::SetDockedMagnifierEnabledForTesting(
+    bool enabled) {
+  if (!active_user_prefs_)
+    return;
+  active_user_prefs_->SetBoolean(prefs::kDockedMagnifierEnabled, enabled);
+  active_user_prefs_->CommitPendingWrite();
+}
+
+bool AccessibilityControllerImpl::IsDockedMagnifierEnabledForTesting() {
+  return active_user_prefs_ &&
+         active_user_prefs_->GetBoolean(prefs::kDockedMagnifierEnabled);
+}
+
+bool AccessibilityControllerImpl::IsDockedMagnifierSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kDockedMagnifierEnabled);
+}
+
 void AccessibilityControllerImpl::SetHighContrastEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -528,7 +571,7 @@ void AccessibilityControllerImpl::SetHighContrastEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
-bool AccessibilityControllerImpl::GetTrayVisiblityOfHighContrastSetting() {
+bool AccessibilityControllerImpl::IsHighContrastSettingVisibleInTray() {
   return IsAccessibilityFeatureVisibleInTrayMenu(
       prefs::kAccessibilityHighContrastEnabled);
 }
@@ -541,7 +584,7 @@ void AccessibilityControllerImpl::SetLargeCursorEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
-bool AccessibilityControllerImpl::GetTrayVisiblityOfLargeCursorSetting() {
+bool AccessibilityControllerImpl::IsLargeCursorSettingVisibleInTray() {
   return IsAccessibilityFeatureVisibleInTrayMenu(
       prefs::kAccessibilityLargeCursorEnabled);
 }
@@ -554,7 +597,7 @@ void AccessibilityControllerImpl::SetMonoAudioEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
-bool AccessibilityControllerImpl::GetTrayVisiblityOfMonoAudioSetting() {
+bool AccessibilityControllerImpl::IsMonoAudioSettingVisibleInTray() {
   return IsAccessibilityFeatureVisibleInTrayMenu(
       prefs::kAccessibilityMonoAudioEnabled);
 }
@@ -579,6 +622,11 @@ void AccessibilityControllerImpl::SetSpokenFeedbackEnabled(
   ShowAccessibilityNotification(type);
 }
 
+bool AccessibilityControllerImpl::IsSpokenFeedbackSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilitySpokenFeedbackEnabled);
+}
+
 void AccessibilityControllerImpl::SetSelectToSpeakEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -587,6 +635,11 @@ void AccessibilityControllerImpl::SetSelectToSpeakEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsSelectToSpeakSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilitySelectToSpeakEnabled);
+}
+
 void AccessibilityControllerImpl::RequestSelectToSpeakStateChange() {
   client_->RequestSelectToSpeakStateChange();
 }
@@ -623,6 +676,11 @@ void AccessibilityControllerImpl::SetSwitchAccessEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsSwitchAccessSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilitySwitchAccessEnabled);
+}
+
 void AccessibilityControllerImpl::SetSwitchAccessIgnoreVirtualKeyEvent(
     bool should_ignore) {
   switch_access_event_handler_->set_ignore_virtual_key_events(should_ignore);
@@ -647,6 +705,11 @@ void AccessibilityControllerImpl::SetStickyKeysEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsStickyKeysSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityStickyKeysEnabled);
+}
+
 void AccessibilityControllerImpl::SetVirtualKeyboardEnabled(bool enabled) {
   if (!active_user_prefs_)
     return;
@@ -655,6 +718,11 @@ void AccessibilityControllerImpl::SetVirtualKeyboardEnabled(bool enabled) {
   active_user_prefs_->CommitPendingWrite();
 }
 
+bool AccessibilityControllerImpl::IsVirtualKeyboardSettingVisibleInTray() {
+  return IsAccessibilityFeatureVisibleInTrayMenu(
+      prefs::kAccessibilityVirtualKeyboardEnabled);
+}
+
 void AccessibilityControllerImpl::TriggerAccessibilityAlert(
     AccessibilityAlert alert) {
   if (client_)

ash/accessibility/accessibility_controller_impl.h

@@ -75,6 +75,8 @@ class ASH_EXPORT AccessibilityControllerImpl : public AccessibilityController,
 
   void SetAutoclickEnabled(bool enabled);
   bool autoclick_enabled() const { return autoclick_enabled_; }
+  bool IsAutoclickSettingVisibleInTray();
+
   void SetAutoclickEventType(AutoclickEventType event_type);
   AutoclickEventType GetAutoclickEventType();
   void SetAutoclickMenuPosition(AutoclickMenuPosition position);
@@ -88,67 +90,65 @@ class ASH_EXPORT AccessibilityControllerImpl : public AccessibilityController,
 
   void SetCaretHighlightEnabled(bool enabled);
   bool caret_highlight_enabled() const { return caret_highlight_enabled_; }
+  bool IsCaretHighlightSettingVisibleInTray();
 
   void SetCursorHighlightEnabled(bool enabled);
   bool cursor_highlight_enabled() const { return cursor_highlight_enabled_; }
-  // Returns true if the cursor highlight is being controlled by a policy
-  // which enforces turning it on or its not being controlled by any type of
-  // policy and false otherwise.
-  bool GetTrayVisiblityOfCursorHighlightSetting();
+  bool IsCursorHighlightSettingVisibleInTray();
 
   void SetDictationEnabled(bool enabled);
   bool dictation_enabled() const { return dictation_enabled_; }
-  // Returns true if the dictation is being controlled by a policy which
-  // enforces turning it on or its not being controlled by any type of policy
-  // and false otherwise.
-  bool GetTrayVisiblityOfDictationSetting();
+  bool IsDictationSettingVisibleInTray();
 
   void SetFocusHighlightEnabled(bool enabled);
   bool focus_highlight_enabled() const { return focus_highlight_enabled_; }
+  bool IsFocusHighlightSettingVisibleInTray();
 
   void SetFullscreenMagnifierEnabled(bool enabled);
+  bool IsFullscreenMagnifierEnabledForTesting();
+  bool IsFullScreenMagnifierSettingVisibleInTray();
+
+  void SetDockedMagnifierEnabledForTesting(bool enabled);
+  bool IsDockedMagnifierEnabledForTesting();
+  bool IsDockedMagnifierSettingVisibleInTray();
 
   void SetHighContrastEnabled(bool enabled);
   bool high_contrast_enabled() const { return high_contrast_enabled_; }
-  // Returns true if the high contrast is being controlled by a policy which
-  // enforces turning it on or its not being controlled by any type of policy
-  // and false otherwise.
-  bool GetTrayVisiblityOfHighContrastSetting();
+  bool IsHighContrastSettingVisibleInTray();
 
   void SetLargeCursorEnabled(bool enabled);
   bool large_cursor_enabled() const { return large_cursor_enabled_; }
-  // Returns true if the large cursor is being controlled by a policy which
-  // enforces turning it on or its not being controlled by any type of policy
-  // and false otherwise.
-  bool GetTrayVisiblityOfLargeCursorSetting();
+  bool IsLargeCursorSettingVisibleInTray();
 
   void SetMonoAudioEnabled(bool enabled);
   bool mono_audio_enabled() const { return mono_audio_enabled_; }
-  // Returns true if the mono audio is being controlled by a policy which
-  // enforces turning it on or its not being controlled by any type of policy
-  // and false otherwise.
-  bool GetTrayVisiblityOfMonoAudioSetting();
+  bool IsMonoAudioSettingVisibleInTray();
 
   void SetSpokenFeedbackEnabled(bool enabled,
                                 AccessibilityNotificationVisibility notify);
   bool spoken_feedback_enabled() const { return spoken_feedback_enabled_; }
+  bool IsSpokenFeedbackSettingVisibleInTray();
 
   void SetSelectToSpeakEnabled(bool enabled);
   bool select_to_speak_enabled() const { return select_to_speak_enabled_; }
+  bool IsSelectToSpeakSettingVisibleInTray();
 
   void RequestSelectToSpeakStateChange();
   SelectToSpeakState GetSelectToSpeakState() const;
 
   void SetStickyKeysEnabled(bool enabled);
   bool sticky_keys_enabled() const { return sticky_keys_enabled_; }
+  bool IsStickyKeysSettingVisibleInTray();
 
   void SetSwitchAccessEnabled(bool enabled);
   bool switch_access_enabled() const { return switch_access_enabled_; }
+  bool IsSwitchAccessSettingVisibleInTray();
 
   void SetSwitchAccessIgnoreVirtualKeyEvent(bool should_ignore);
 
   void SetVirtualKeyboardEnabled(bool enabled);
   bool virtual_keyboard_enabled() const { return virtual_keyboard_enabled_; }
+  bool IsVirtualKeyboardSettingVisibleInTray();
 
   bool dictation_active() const { return dictation_active_; }
 

ash/accessibility/accessibility_controller_unittest.cc

@@ -204,13 +204,13 @@ TEST_F(AccessibilityControllerTest, LargeCursorTrayMenuVisibility) {
   EXPECT_TRUE(controller->large_cursor_enabled());
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityLargeCursorEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfLargeCursorSetting());
+  EXPECT_TRUE(controller->IsLargeCursorSettingVisibleInTray());
   // Check when the value is false and not being controlled by any policy.
   controller->SetLargeCursorEnabled(false);
   EXPECT_FALSE(controller->large_cursor_enabled());
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityLargeCursorEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfLargeCursorSetting());
+  EXPECT_TRUE(controller->IsLargeCursorSettingVisibleInTray());
 
   // Check that when the pref is managed and being forced on then it will be
   // visible.
@@ -220,7 +220,7 @@ TEST_F(AccessibilityControllerTest, LargeCursorTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityLargeCursorEnabled));
   EXPECT_TRUE(controller->large_cursor_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfLargeCursorSetting());
+  EXPECT_TRUE(controller->IsLargeCursorSettingVisibleInTray());
   // Check that when the pref is managed and only being forced off then it will
   // be invisible.
   static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
@@ -229,7 +229,7 @@ TEST_F(AccessibilityControllerTest, LargeCursorTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityLargeCursorEnabled));
   EXPECT_FALSE(controller->large_cursor_enabled());
-  EXPECT_FALSE(controller->GetTrayVisiblityOfLargeCursorSetting());
+  EXPECT_FALSE(controller->IsLargeCursorSettingVisibleInTray());
 }
 
 TEST_F(AccessibilityControllerTest, HighContrastTrayMenuVisibility) {
@@ -244,13 +244,13 @@ TEST_F(AccessibilityControllerTest, HighContrastTrayMenuVisibility) {
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityHighContrastEnabled));
   EXPECT_TRUE(controller->high_contrast_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfHighContrastSetting());
+  EXPECT_TRUE(controller->IsHighContrastSettingVisibleInTray());
   // Check when the value is false and not being controlled by any policy.
   controller->SetHighContrastEnabled(false);
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityHighContrastEnabled));
   EXPECT_FALSE(controller->high_contrast_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfHighContrastSetting());
+  EXPECT_TRUE(controller->IsHighContrastSettingVisibleInTray());
 
   // Check that when the pref is managed and being forced on then it will be
   // visible.
@@ -259,7 +259,7 @@ TEST_F(AccessibilityControllerTest, HighContrastTrayMenuVisibility) {
       std::make_unique<base::Value>(true));
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityHighContrastEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfHighContrastSetting());
+  EXPECT_TRUE(controller->IsHighContrastSettingVisibleInTray());
   // Check that when the pref is managed and only being forced off then it will
   // be invisible.
   static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
@@ -268,7 +268,7 @@ TEST_F(AccessibilityControllerTest, HighContrastTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityHighContrastEnabled));
   EXPECT_FALSE(controller->high_contrast_enabled());
-  EXPECT_FALSE(controller->GetTrayVisiblityOfHighContrastSetting());
+  EXPECT_FALSE(controller->IsHighContrastSettingVisibleInTray());
 }
 
 TEST_F(AccessibilityControllerTest, MonoAudioTrayMenuVisibility) {
@@ -283,13 +283,13 @@ TEST_F(AccessibilityControllerTest, MonoAudioTrayMenuVisibility) {
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityMonoAudioEnabled));
   EXPECT_TRUE(controller->mono_audio_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfMonoAudioSetting());
+  EXPECT_TRUE(controller->IsMonoAudioSettingVisibleInTray());
   // Check when the value is false and not being controlled by any policy.
   controller->SetMonoAudioEnabled(false);
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityMonoAudioEnabled));
   EXPECT_FALSE(controller->mono_audio_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfMonoAudioSetting());
+  EXPECT_TRUE(controller->IsMonoAudioSettingVisibleInTray());
 
   // Check that when the pref is managed and being forced on then it will be
   // visible.
@@ -298,7 +298,7 @@ TEST_F(AccessibilityControllerTest, MonoAudioTrayMenuVisibility) {
       std::make_unique<base::Value>(true));
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityMonoAudioEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfMonoAudioSetting());
+  EXPECT_TRUE(controller->IsMonoAudioSettingVisibleInTray());
   // Check that when the pref is managed and only being forced off then it will
   // be invisible.
   static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
@@ -307,7 +307,7 @@ TEST_F(AccessibilityControllerTest, MonoAudioTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityMonoAudioEnabled));
   EXPECT_FALSE(controller->mono_audio_enabled());
-  EXPECT_FALSE(controller->GetTrayVisiblityOfMonoAudioSetting());
+  EXPECT_FALSE(controller->IsMonoAudioSettingVisibleInTray());
 }
 
 TEST_F(AccessibilityControllerTest, DictationTrayMenuVisibility) {
@@ -325,13 +325,13 @@ TEST_F(AccessibilityControllerTest, DictationTrayMenuVisibility) {
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityDictationEnabled));
   EXPECT_TRUE(controller->dictation_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfDictationSetting());
+  EXPECT_TRUE(controller->IsDictationSettingVisibleInTray());
   // Check when the value is false and not being controlled by any policy.
   controller->SetDictationEnabled(false);
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityDictationEnabled));
   EXPECT_FALSE(controller->dictation_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfDictationSetting());
+  EXPECT_TRUE(controller->IsDictationSettingVisibleInTray());
 
   // Check that when the pref is managed and being forced on then it will be
   // visible.
@@ -340,7 +340,7 @@ TEST_F(AccessibilityControllerTest, DictationTrayMenuVisibility) {
       std::make_unique<base::Value>(true));
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityDictationEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfDictationSetting());
+  EXPECT_TRUE(controller->IsDictationSettingVisibleInTray());
   // Check that when the pref is managed and only being forced off then it will
   // be invisible.
   static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
@@ -349,7 +349,7 @@ TEST_F(AccessibilityControllerTest, DictationTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityDictationEnabled));
   EXPECT_FALSE(controller->dictation_enabled());
-  EXPECT_FALSE(controller->GetTrayVisiblityOfDictationSetting());
+  EXPECT_FALSE(controller->IsDictationSettingVisibleInTray());
 }
 
 TEST_F(AccessibilityControllerTest, CursorHighlightTrayMenuVisibility) {
@@ -364,13 +364,13 @@ TEST_F(AccessibilityControllerTest, CursorHighlightTrayMenuVisibility) {
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityCursorHighlightEnabled));
   EXPECT_TRUE(controller->cursor_highlight_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfCursorHighlightSetting());
+  EXPECT_TRUE(controller->IsCursorHighlightSettingVisibleInTray());
   // Check when the value is false and not being controlled by any policy.
   controller->SetCursorHighlightEnabled(false);
   EXPECT_FALSE(
       prefs->IsManagedPreference(prefs::kAccessibilityCursorHighlightEnabled));
   EXPECT_FALSE(controller->cursor_highlight_enabled());
-  EXPECT_TRUE(controller->GetTrayVisiblityOfCursorHighlightSetting());
+  EXPECT_TRUE(controller->IsCursorHighlightSettingVisibleInTray());
 
   // Check that when the pref is managed and being forced on then it will be
   // visible.
@@ -379,7 +379,7 @@ TEST_F(AccessibilityControllerTest, CursorHighlightTrayMenuVisibility) {
       std::make_unique<base::Value>(true));
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityCursorHighlightEnabled));
-  EXPECT_TRUE(controller->GetTrayVisiblityOfCursorHighlightSetting());
+  EXPECT_TRUE(controller->IsCursorHighlightSettingVisibleInTray());
   // Check that when the pref is managed and only being forced off then it will
   // be invisible.
   static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
@@ -388,7 +388,390 @@ TEST_F(AccessibilityControllerTest, CursorHighlightTrayMenuVisibility) {
   EXPECT_TRUE(
       prefs->IsManagedPreference(prefs::kAccessibilityCursorHighlightEnabled));
   EXPECT_FALSE(controller->cursor_highlight_enabled());
-  EXPECT_FALSE(controller->GetTrayVisiblityOfCursorHighlightSetting());
+  EXPECT_FALSE(controller->IsCursorHighlightSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, FullScreenMagnifierTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetFullscreenMagnifierEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityScreenMagnifierEnabled));
+  EXPECT_TRUE(controller->IsFullscreenMagnifierEnabledForTesting());
+  EXPECT_TRUE(controller->IsFullScreenMagnifierSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetFullscreenMagnifierEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityScreenMagnifierEnabled));
+  EXPECT_FALSE(controller->IsFullscreenMagnifierEnabledForTesting());
+  EXPECT_TRUE(controller->IsFullScreenMagnifierSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityScreenMagnifierEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityScreenMagnifierEnabled));
+  EXPECT_TRUE(controller->IsFullScreenMagnifierSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityScreenMagnifierEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityScreenMagnifierEnabled));
+  EXPECT_FALSE(controller->IsFullscreenMagnifierEnabledForTesting());
+  EXPECT_FALSE(controller->IsFullScreenMagnifierSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, DockedMagnifierTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetDockedMagnifierEnabledForTesting(true);
+  EXPECT_FALSE(prefs->IsManagedPreference(prefs::kDockedMagnifierEnabled));
+  EXPECT_TRUE(controller->IsDockedMagnifierEnabledForTesting());
+  EXPECT_TRUE(controller->IsDockedMagnifierSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetDockedMagnifierEnabledForTesting(false);
+  EXPECT_FALSE(prefs->IsManagedPreference(prefs::kDockedMagnifierEnabled));
+  EXPECT_FALSE(controller->IsDockedMagnifierEnabledForTesting());
+  EXPECT_TRUE(controller->IsDockedMagnifierSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kDockedMagnifierEnabled, std::make_unique<base::Value>(true));
+  EXPECT_TRUE(prefs->IsManagedPreference(prefs::kDockedMagnifierEnabled));
+  EXPECT_TRUE(controller->IsDockedMagnifierSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kDockedMagnifierEnabled, std::make_unique<base::Value>(false));
+  EXPECT_TRUE(prefs->IsManagedPreference(prefs::kDockedMagnifierEnabled));
+  EXPECT_FALSE(controller->IsDockedMagnifierEnabledForTesting());
+  EXPECT_FALSE(controller->IsDockedMagnifierSettingVisibleInTray());
+}
+TEST_F(AccessibilityControllerTest, CaretHighlightTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetCaretHighlightEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityCaretHighlightEnabled));
+  EXPECT_TRUE(controller->caret_highlight_enabled());
+  EXPECT_TRUE(controller->IsCaretHighlightSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetCaretHighlightEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityCaretHighlightEnabled));
+  EXPECT_FALSE(controller->caret_highlight_enabled());
+  EXPECT_TRUE(controller->IsCaretHighlightSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityCaretHighlightEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityCaretHighlightEnabled));
+  EXPECT_TRUE(controller->IsCaretHighlightSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityCaretHighlightEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityCaretHighlightEnabled));
+  EXPECT_FALSE(controller->caret_highlight_enabled());
+  EXPECT_FALSE(controller->IsCaretHighlightSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, SelectToSpeakTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetSelectToSpeakEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySelectToSpeakEnabled));
+  EXPECT_TRUE(controller->select_to_speak_enabled());
+  EXPECT_TRUE(controller->IsSelectToSpeakSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetSelectToSpeakEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySelectToSpeakEnabled));
+  EXPECT_FALSE(controller->select_to_speak_enabled());
+  EXPECT_TRUE(controller->IsSelectToSpeakSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySelectToSpeakEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySelectToSpeakEnabled));
+  EXPECT_TRUE(controller->IsSelectToSpeakSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySelectToSpeakEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySelectToSpeakEnabled));
+  EXPECT_FALSE(controller->select_to_speak_enabled());
+  EXPECT_FALSE(controller->IsSelectToSpeakSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, AutoClickTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetAutoclickEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityAutoclickEnabled));
+  EXPECT_TRUE(controller->autoclick_enabled());
+  EXPECT_TRUE(controller->IsAutoclickSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetAutoclickEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityAutoclickEnabled));
+  EXPECT_FALSE(controller->autoclick_enabled());
+  EXPECT_TRUE(controller->IsAutoclickSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityAutoclickEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityAutoclickEnabled));
+  EXPECT_TRUE(controller->IsAutoclickSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityAutoclickEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityAutoclickEnabled));
+  EXPECT_FALSE(controller->autoclick_enabled());
+  EXPECT_FALSE(controller->IsAutoclickSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, SpokenFeedbackTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetSpokenFeedbackEnabled(true, A11Y_NOTIFICATION_NONE);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySpokenFeedbackEnabled));
+  EXPECT_TRUE(controller->spoken_feedback_enabled());
+  EXPECT_TRUE(controller->IsSpokenFeedbackSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetSpokenFeedbackEnabled(false, A11Y_NOTIFICATION_NONE);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySpokenFeedbackEnabled));
+  EXPECT_FALSE(controller->spoken_feedback_enabled());
+  EXPECT_TRUE(controller->IsSpokenFeedbackSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySpokenFeedbackEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySpokenFeedbackEnabled));
+  EXPECT_TRUE(controller->IsSpokenFeedbackSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySpokenFeedbackEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySpokenFeedbackEnabled));
+  EXPECT_FALSE(controller->spoken_feedback_enabled());
+  EXPECT_FALSE(controller->IsSpokenFeedbackSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, VirtualKeyboardTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetVirtualKeyboardEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityVirtualKeyboardEnabled));
+  EXPECT_TRUE(controller->virtual_keyboard_enabled());
+  EXPECT_TRUE(controller->IsVirtualKeyboardSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetVirtualKeyboardEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityVirtualKeyboardEnabled));
+  EXPECT_FALSE(controller->virtual_keyboard_enabled());
+  EXPECT_TRUE(controller->IsVirtualKeyboardSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityVirtualKeyboardEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityVirtualKeyboardEnabled));
+  EXPECT_TRUE(controller->IsVirtualKeyboardSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityVirtualKeyboardEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityVirtualKeyboardEnabled));
+  EXPECT_FALSE(controller->virtual_keyboard_enabled());
+  EXPECT_FALSE(controller->IsVirtualKeyboardSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, SwitchAccessTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetSwitchAccessEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySwitchAccessEnabled));
+  EXPECT_TRUE(controller->switch_access_enabled());
+  EXPECT_TRUE(controller->IsSwitchAccessSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetSwitchAccessEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySwitchAccessEnabled));
+  EXPECT_FALSE(controller->switch_access_enabled());
+  EXPECT_TRUE(controller->IsSwitchAccessSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySwitchAccessEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySwitchAccessEnabled));
+  EXPECT_TRUE(controller->IsSwitchAccessSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilitySwitchAccessEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilitySwitchAccessEnabled));
+  EXPECT_FALSE(controller->switch_access_enabled());
+  EXPECT_FALSE(controller->IsSwitchAccessSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, FocusHighlightTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetFocusHighlightEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityFocusHighlightEnabled));
+  EXPECT_TRUE(controller->focus_highlight_enabled());
+  EXPECT_TRUE(controller->IsFocusHighlightSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetFocusHighlightEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityFocusHighlightEnabled));
+  EXPECT_FALSE(controller->focus_highlight_enabled());
+  EXPECT_TRUE(controller->IsFocusHighlightSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityFocusHighlightEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityFocusHighlightEnabled));
+  EXPECT_TRUE(controller->IsFocusHighlightSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityFocusHighlightEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityFocusHighlightEnabled));
+  EXPECT_FALSE(controller->focus_highlight_enabled());
+  EXPECT_FALSE(controller->IsFocusHighlightSettingVisibleInTray());
+}
+
+TEST_F(AccessibilityControllerTest, StickyKeysTrayMenuVisibility) {
+  // Check that when the pref isn't being controlled by any policy will be
+  // visible in the accessibility tray menu despite its value.
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  AccessibilityControllerImpl* controller =
+      Shell::Get()->accessibility_controller();
+  // Check when the value is true and not being controlled by any policy.
+  controller->SetStickyKeysEnabled(true);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityStickyKeysEnabled));
+  EXPECT_TRUE(controller->sticky_keys_enabled());
+  EXPECT_TRUE(controller->IsStickyKeysSettingVisibleInTray());
+  // Check when the value is false and not being controlled by any policy.
+  controller->SetStickyKeysEnabled(false);
+  EXPECT_FALSE(
+      prefs->IsManagedPreference(prefs::kAccessibilityStickyKeysEnabled));
+  EXPECT_FALSE(controller->sticky_keys_enabled());
+  EXPECT_TRUE(controller->IsStickyKeysSettingVisibleInTray());
+
+  // Check that when the pref is managed and being forced on then it will be
+  // visible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityStickyKeysEnabled,
+      std::make_unique<base::Value>(true));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityStickyKeysEnabled));
+  EXPECT_TRUE(controller->IsStickyKeysSettingVisibleInTray());
+  // Check that when the pref is managed and only being forced off then it will
+  // be invisible.
+  static_cast<TestingPrefServiceSimple*>(prefs)->SetManagedPref(
+      prefs::kAccessibilityStickyKeysEnabled,
+      std::make_unique<base::Value>(false));
+  EXPECT_TRUE(
+      prefs->IsManagedPreference(prefs::kAccessibilityStickyKeysEnabled));
+  EXPECT_FALSE(controller->sticky_keys_enabled());
+  EXPECT_FALSE(controller->IsStickyKeysSettingVisibleInTray());
 }
 
 TEST_F(AccessibilityControllerTest, DisableLargeCursorResetsSize) {

ash/system/accessibility/tray_accessibility.cc

@@ -72,83 +72,104 @@ void AccessibilityDetailedView::OnAccessibilityStatusChanged() {
   AccessibilityControllerImpl* controller =
       Shell::Get()->accessibility_controller();
 
-  spoken_feedback_enabled_ = controller->spoken_feedback_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(spoken_feedback_view_,
-                                            spoken_feedback_enabled_);
+  if (spoken_feedback_view_ &&
+      controller->IsSpokenFeedbackSettingVisibleInTray()) {
+    spoken_feedback_enabled_ = controller->spoken_feedback_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(spoken_feedback_view_,
+                                              spoken_feedback_enabled_);
+  }
 
-  select_to_speak_enabled_ = controller->select_to_speak_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(select_to_speak_view_,
-                                            select_to_speak_enabled_);
+  if (select_to_speak_view_ &&
+      controller->IsSelectToSpeakSettingVisibleInTray()) {
+    select_to_speak_enabled_ = controller->select_to_speak_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(select_to_speak_view_,
+                                              select_to_speak_enabled_);
+  }
 
-  if (dictation_view_ && controller->GetTrayVisiblityOfDictationSetting()) {
+  if (dictation_view_ && controller->IsDictationSettingVisibleInTray()) {
     dictation_enabled_ = controller->dictation_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(dictation_view_,
                                               dictation_enabled_);
   }
 
-  if (high_contrast_view_ &&
-      controller->GetTrayVisiblityOfHighContrastSetting()) {
+  if (high_contrast_view_ && controller->IsHighContrastSettingVisibleInTray()) {
     high_contrast_enabled_ = controller->high_contrast_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(high_contrast_view_,
                                               high_contrast_enabled_);
   }
 
-  screen_magnifier_enabled_ = delegate->IsMagnifierEnabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(screen_magnifier_view_,
-                                            screen_magnifier_enabled_);
+  if (screen_magnifier_view_ &&
+      controller->IsFullScreenMagnifierSettingVisibleInTray()) {
+    screen_magnifier_enabled_ = delegate->IsMagnifierEnabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(screen_magnifier_view_,
+                                              screen_magnifier_enabled_);
+  }
 
-  docked_magnifier_enabled_ =
-      Shell::Get()->docked_magnifier_controller()->GetEnabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(docked_magnifier_view_,
-                                            docked_magnifier_enabled_);
+  if (docked_magnifier_view_ &&
+      controller->IsDockedMagnifierSettingVisibleInTray()) {
+    docked_magnifier_enabled_ =
+        Shell::Get()->docked_magnifier_controller()->GetEnabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(docked_magnifier_view_,
+                                              docked_magnifier_enabled_);
+  }
 
-  autoclick_enabled_ = controller->autoclick_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(autoclick_view_,
-                                            autoclick_enabled_);
+  if (autoclick_view_ && controller->IsAutoclickSettingVisibleInTray()) {
+    autoclick_enabled_ = controller->autoclick_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(autoclick_view_,
+                                              autoclick_enabled_);
+  }
 
-  virtual_keyboard_enabled_ = controller->virtual_keyboard_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(virtual_keyboard_view_,
-                                            virtual_keyboard_enabled_);
+  if (virtual_keyboard_view_ &&
+      controller->IsVirtualKeyboardSettingVisibleInTray()) {
+    virtual_keyboard_enabled_ = controller->virtual_keyboard_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(virtual_keyboard_view_,
+                                              virtual_keyboard_enabled_);
+  }
 
-  if (switch_access_view_) {
+  if (switch_access_view_ && controller->IsSwitchAccessSettingVisibleInTray()) {
     switch_access_enabled_ = controller->switch_access_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(switch_access_view_,
                                               switch_access_enabled_);
   }
 
-  if (large_cursor_view_ &&
-      controller->GetTrayVisiblityOfLargeCursorSetting()) {
+  if (large_cursor_view_ && controller->IsLargeCursorSettingVisibleInTray()) {
     large_cursor_enabled_ = controller->large_cursor_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(large_cursor_view_,
                                               large_cursor_enabled_);
   }
 
-  if (mono_audio_view_ && controller->GetTrayVisiblityOfMonoAudioSetting()) {
+  if (mono_audio_view_ && controller->IsMonoAudioSettingVisibleInTray()) {
     mono_audio_enabled_ = controller->mono_audio_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(mono_audio_view_,
                                               mono_audio_enabled_);
   }
 
-  caret_highlight_enabled_ = controller->caret_highlight_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(caret_highlight_view_,
-                                            caret_highlight_enabled_);
+  if (caret_highlight_view_ &&
+      controller->IsCaretHighlightSettingVisibleInTray()) {
+    caret_highlight_enabled_ = controller->caret_highlight_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(caret_highlight_view_,
+                                              caret_highlight_enabled_);
+  }
 
   if (highlight_mouse_cursor_view_ &&
-      controller->GetTrayVisiblityOfCursorHighlightSetting()) {
+      controller->IsCursorHighlightSettingVisibleInTray()) {
     highlight_mouse_cursor_enabled_ = controller->cursor_highlight_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(highlight_mouse_cursor_view_,
                                               highlight_mouse_cursor_enabled_);
   }
 
-  if (highlight_keyboard_focus_view_) {
+  if (highlight_keyboard_focus_view_ &&
+      controller->IsFocusHighlightSettingVisibleInTray()) {
     highlight_keyboard_focus_enabled_ = controller->focus_highlight_enabled();
     TrayPopupUtils::UpdateCheckMarkVisibility(
         highlight_keyboard_focus_view_, highlight_keyboard_focus_enabled_);
   }
 
-  sticky_keys_enabled_ = controller->sticky_keys_enabled();
-  TrayPopupUtils::UpdateCheckMarkVisibility(sticky_keys_view_,
-                                            sticky_keys_enabled_);
+  if (sticky_keys_view_ && controller->IsStickyKeysSettingVisibleInTray()) {
+    sticky_keys_enabled_ = controller->sticky_keys_enabled();
+    TrayPopupUtils::UpdateCheckMarkVisibility(sticky_keys_view_,
+                                              sticky_keys_enabled_);
+  }
 }
 
 const char* AccessibilityDetailedView::GetClassName() const {
@@ -162,21 +183,25 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
   AccessibilityControllerImpl* controller =
       Shell::Get()->accessibility_controller();
 
-  spoken_feedback_enabled_ = controller->spoken_feedback_enabled();
-  spoken_feedback_view_ = AddScrollListCheckableItem(
-      kSystemMenuAccessibilityChromevoxIcon,
-      l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SPOKEN_FEEDBACK),
-      spoken_feedback_enabled_);
-
-  select_to_speak_enabled_ = controller->select_to_speak_enabled();
-  select_to_speak_view_ = AddScrollListCheckableItem(
-      kSystemMenuAccessibilitySelectToSpeakIcon,
-      l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SELECT_TO_SPEAK),
-      select_to_speak_enabled_);
-
-  if (controller->GetTrayVisiblityOfDictationSetting()) {
+  if (controller->IsSpokenFeedbackSettingVisibleInTray()) {
+    spoken_feedback_enabled_ = controller->spoken_feedback_enabled();
+    spoken_feedback_view_ = AddScrollListCheckableItem(
+        kSystemMenuAccessibilityChromevoxIcon,
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SPOKEN_FEEDBACK),
+        spoken_feedback_enabled_);
+  }
+
+  if (controller->IsSelectToSpeakSettingVisibleInTray()) {
+    select_to_speak_enabled_ = controller->select_to_speak_enabled();
+    select_to_speak_view_ = AddScrollListCheckableItem(
+        kSystemMenuAccessibilitySelectToSpeakIcon,
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SELECT_TO_SPEAK),
+        select_to_speak_enabled_);
+  }
+
+  if (controller->IsDictationSettingVisibleInTray()) {
     dictation_enabled_ = controller->dictation_enabled();
     dictation_view_ = AddScrollListCheckableItem(
         kDictationMenuIcon,
@@ -184,7 +209,7 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
         dictation_enabled_);
   }
 
-  if (controller->GetTrayVisiblityOfHighContrastSetting()) {
+  if (controller->IsHighContrastSettingVisibleInTray()) {
     high_contrast_enabled_ = controller->high_contrast_enabled();
     high_contrast_view_ = AddScrollListCheckableItem(
         kSystemMenuAccessibilityContrastIcon,
@@ -193,13 +218,16 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
         high_contrast_enabled_);
   }
 
-  screen_magnifier_enabled_ = delegate->IsMagnifierEnabled();
-  screen_magnifier_view_ = AddScrollListCheckableItem(
-      kSystemMenuAccessibilityFullscreenMagnifierIcon,
-      l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SCREEN_MAGNIFIER),
-      screen_magnifier_enabled_);
+  if (controller->IsFullScreenMagnifierSettingVisibleInTray()) {
+    screen_magnifier_enabled_ = delegate->IsMagnifierEnabled();
+    screen_magnifier_view_ = AddScrollListCheckableItem(
+        kSystemMenuAccessibilityFullscreenMagnifierIcon,
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_SCREEN_MAGNIFIER),
+        screen_magnifier_enabled_);
+  }
 
+  if (controller->IsDockedMagnifierSettingVisibleInTray()) {
     docked_magnifier_enabled_ =
         Shell::Get()->docked_magnifier_controller()->GetEnabled();
     docked_magnifier_view_ = AddScrollListCheckableItem(
@@ -207,25 +235,31 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
         l10n_util::GetStringUTF16(
             IDS_ASH_STATUS_TRAY_ACCESSIBILITY_DOCKED_MAGNIFIER),
         docked_magnifier_enabled_);
+  }
 
-  autoclick_enabled_ = controller->autoclick_enabled();
-  autoclick_view_ = AddScrollListCheckableItem(
-      kSystemMenuAccessibilityAutoClickIcon,
-      l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBILITY_AUTOCLICK),
-      autoclick_enabled_);
-
-  virtual_keyboard_enabled_ = controller->virtual_keyboard_enabled();
-  virtual_keyboard_view_ = AddScrollListCheckableItem(
-      kSystemMenuKeyboardIcon,
-      l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_ACCESSIBILITY_VIRTUAL_KEYBOARD),
-      virtual_keyboard_enabled_);
-  virtual_keyboard_view_->SetID(ash::VIEW_ID_ACCESSIBILITY_VIRTUAL_KEYBOARD);
-  virtual_keyboard_view_->right_view()->SetID(
-      ash::VIEW_ID_ACCESSIBILITY_VIRTUAL_KEYBOARD_ENABLED);
+  if (controller->IsAutoclickSettingVisibleInTray()) {
+    autoclick_enabled_ = controller->autoclick_enabled();
+    autoclick_view_ = AddScrollListCheckableItem(
+        kSystemMenuAccessibilityAutoClickIcon,
+        l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBILITY_AUTOCLICK),
+        autoclick_enabled_);
+  }
+
+  if (controller->IsVirtualKeyboardSettingVisibleInTray()) {
+    virtual_keyboard_enabled_ = controller->virtual_keyboard_enabled();
+    virtual_keyboard_view_ = AddScrollListCheckableItem(
+        kSystemMenuKeyboardIcon,
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_VIRTUAL_KEYBOARD),
+        virtual_keyboard_enabled_);
+    virtual_keyboard_view_->SetID(ash::VIEW_ID_ACCESSIBILITY_VIRTUAL_KEYBOARD);
+    virtual_keyboard_view_->right_view()->SetID(
+        ash::VIEW_ID_ACCESSIBILITY_VIRTUAL_KEYBOARD_ENABLED);
+  }
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableExperimentalAccessibilitySwitchAccess)) {
+          switches::kEnableExperimentalAccessibilitySwitchAccess) &&
+      controller->IsSwitchAccessSettingVisibleInTray()) {
     switch_access_enabled_ = controller->switch_access_enabled();
     switch_access_view_ = AddScrollListCheckableItem(
         kSwitchAccessIcon,
@@ -238,7 +272,7 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
 
   AddScrollListSubHeader(IDS_ASH_STATUS_TRAY_ACCESSIBILITY_ADDITIONAL_SETTINGS);
 
-  if (controller->GetTrayVisiblityOfLargeCursorSetting()) {
+  if (controller->IsLargeCursorSettingVisibleInTray()) {
     large_cursor_enabled_ = controller->large_cursor_enabled();
     large_cursor_view_ = AddScrollListCheckableItem(
         l10n_util::GetStringUTF16(
@@ -246,20 +280,22 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
         large_cursor_enabled_);
   }
 
-  if (controller->GetTrayVisiblityOfMonoAudioSetting()) {
+  if (controller->IsMonoAudioSettingVisibleInTray()) {
     mono_audio_enabled_ = controller->mono_audio_enabled();
     mono_audio_view_ = AddScrollListCheckableItem(
         l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBILITY_MONO_AUDIO),
         mono_audio_enabled_);
   }
 
-  caret_highlight_enabled_ = controller->caret_highlight_enabled();
-  caret_highlight_view_ = AddScrollListCheckableItem(
-      l10n_util::GetStringUTF16(
-          IDS_ASH_STATUS_TRAY_ACCESSIBILITY_CARET_HIGHLIGHT),
-      caret_highlight_enabled_);
+  if (controller->IsCaretHighlightSettingVisibleInTray()) {
+    caret_highlight_enabled_ = controller->caret_highlight_enabled();
+    caret_highlight_view_ = AddScrollListCheckableItem(
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_CARET_HIGHLIGHT),
+        caret_highlight_enabled_);
+  }
 
-  if (controller->GetTrayVisiblityOfCursorHighlightSetting()) {
+  if (controller->IsCursorHighlightSettingVisibleInTray()) {
     highlight_mouse_cursor_enabled_ = controller->cursor_highlight_enabled();
     highlight_mouse_cursor_view_ = AddScrollListCheckableItem(
         l10n_util::GetStringUTF16(
@@ -268,7 +304,8 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
   }
   // Focus highlighting can't be on when spoken feedback is on because
   // ChromeVox does its own focus highlighting.
-  if (!spoken_feedback_enabled_) {
+  if (!spoken_feedback_enabled_ &&
+      controller->IsFocusHighlightSettingVisibleInTray()) {
     highlight_keyboard_focus_enabled_ = controller->focus_highlight_enabled();
     highlight_keyboard_focus_view_ = AddScrollListCheckableItem(
         l10n_util::GetStringUTF16(
@@ -276,10 +313,13 @@ void AccessibilityDetailedView::AppendAccessibilityList() {
         highlight_keyboard_focus_enabled_);
   }
 
-  sticky_keys_enabled_ = controller->sticky_keys_enabled();
-  sticky_keys_view_ = AddScrollListCheckableItem(
-      l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBILITY_STICKY_KEYS),
-      sticky_keys_enabled_);
+  if (controller->IsStickyKeysSettingVisibleInTray()) {
+    sticky_keys_enabled_ = controller->sticky_keys_enabled();
+    sticky_keys_view_ = AddScrollListCheckableItem(
+        l10n_util::GetStringUTF16(
+            IDS_ASH_STATUS_TRAY_ACCESSIBILITY_STICKY_KEYS),
+        sticky_keys_enabled_);
+  }
 }
 
 void AccessibilityDetailedView::HandleViewClicked(views::View* view) {