Turn back spoken feedback setting into a system-wide (non-per-user) preference

chrome/browser/chromeos/accessibility/accessibility_manager.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/session_state_delegate.h"
@@ skipping 273 matching lines @@
 // static
 AccessibilityManager* AccessibilityManager::Get() {
   return g_accessibility_manager;
 }
 
 AccessibilityManager::AccessibilityManager()
     : profile_(NULL),
       chrome_vox_loaded_on_lock_screen_(false),
       chrome_vox_loaded_on_user_screen_(false),
       large_cursor_pref_handler_(prefs::kLargeCursorEnabled),
-      spoken_feedback_pref_handler_(prefs::kSpokenFeedbackEnabled),
       high_contrast_pref_handler_(prefs::kHighContrastEnabled),
       autoclick_pref_handler_(prefs::kAutoclickEnabled),
       autoclick_delay_pref_handler_(prefs::kAutoclickDelayMs),
       large_cursor_enabled_(false),
       sticky_keys_enabled_(false),
       spoken_feedback_enabled_(false),
       high_contrast_enabled_(false),
       autoclick_enabled_(false),
       autoclick_delay_ms_(ash::AutoclickController::kDefaultAutoclickDelayMs),
       spoken_feedback_notification_(ash::A11Y_NOTIFICATION_NONE),
@@ skipping 40 matching lines @@
   // we clean up ChromeVox observers here.
   for (std::set<Profile*>::iterator it = chromevox_profiles_.begin();
        it != chromevox_profiles_.end();
        it++) {
     extensions::ExtensionSystem::Get(*it)->
         event_router()->UnregisterObserver(this);
   }
 }
 
 bool AccessibilityManager::ShouldShowAccessibilityMenu() {
+  if (!g_browser_process)
+    return false;
+
+  PrefService* global_pref_service = g_browser_process->local_state();
+  if (global_pref_service->GetBoolean(prefs::kSpokenFeedbackEnabled))
+    return true;
+
   // If any of the loaded profiles has an accessibility feature turned on - or
   // enforced to always show the menu - we return true to show the menu.
   std::vector<Profile*> profiles =
       g_browser_process->profile_manager()->GetLoadedProfiles();
   for (std::vector<Profile*>::iterator it = profiles.begin();
        it != profiles.end();
        ++it) {
     PrefService* pref_service = (*it)->GetPrefs();
     if (pref_service->GetBoolean(prefs::kStickyKeysEnabled) ||
         pref_service->GetBoolean(prefs::kLargeCursorEnabled) ||
-        pref_service->GetBoolean(prefs::kSpokenFeedbackEnabled) ||
         pref_service->GetBoolean(prefs::kHighContrastEnabled) ||
         pref_service->GetBoolean(prefs::kAutoclickEnabled) ||
         pref_service->GetBoolean(prefs::kShouldAlwaysShowAccessibilityMenu) ||
         pref_service->GetBoolean(prefs::kScreenMagnifierEnabled))
       return true;
   }
   return false;
 }
 
 void AccessibilityManager::EnableLargeCursor(bool enabled) {
@@ skipping 65 matching lines @@
   sticky_keys_enabled_ = enabled;
 #if defined(USE_ASH)
   // Sticky keys is implemented only in ash.
   ash::Shell::GetInstance()->sticky_keys_controller()->Enable(enabled);
 #endif
 }
 
 void AccessibilityManager::EnableSpokenFeedback(
     bool enabled,
     ash::AccessibilityNotificationVisibility notify) {
-  if (!profile_)
+  if (!g_browser_process)
     return;
 
   ash::Shell::GetInstance()->metrics()->RecordUserMetricsAction(
       enabled ? ash::UMA_STATUS_AREA_ENABLE_SPOKEN_FEEDBACK
               : ash::UMA_STATUS_AREA_DISABLE_SPOKEN_FEEDBACK);
 
   spoken_feedback_notification_ = notify;
 
-  PrefService* pref_service = profile_->GetPrefs();
-  pref_service->SetBoolean(
-      prefs::kSpokenFeedbackEnabled, enabled);
-  pref_service->CommitPendingWrite();
+  PrefService* global_pref_service = g_browser_process->local_state();
+  global_pref_service->SetBoolean(
+        prefs::kSpokenFeedbackEnabled, enabled);
+  global_pref_service->CommitPendingWrite();
 
   spoken_feedback_notification_ = ash::A11Y_NOTIFICATION_NONE;
 }
 
 void AccessibilityManager::UpdateSpokenFeedbackFromPref() {
-  if (!profile_)
+  if (!g_browser_process)
     return;
 
+  PrefService* global_pref_service = g_browser_process->local_state();
   const bool enabled =
-      profile_->GetPrefs()->GetBoolean(prefs::kSpokenFeedbackEnabled);
+      global_pref_service->GetBoolean(prefs::kSpokenFeedbackEnabled);
 
   if (spoken_feedback_enabled_ == enabled)
     return;
 
   spoken_feedback_enabled_ = enabled;
 
   ExtensionAccessibilityEventRouter::GetInstance()->
       SetAccessibilityEnabled(enabled);
 
   AccessibilityStatusEventDetails details(enabled,
@@ skipping 35 matching lines @@
   content::WebUI* login_web_ui = NULL;
 
   if (ProfileHelper::IsSigninProfile(profile_)) {
     LoginDisplayHost* login_display_host = LoginDisplayHostImpl::default_host();
     if (login_display_host) {
       WebUILoginView* web_ui_login_view =
           login_display_host->GetWebUILoginView();
       if (web_ui_login_view)
         login_web_ui = web_ui_login_view->GetWebUI();
     }
+
+    // Lock screen uses the signin progile.
+    chrome_vox_loaded_on_lock_screen_ = true;
   }
 
   LoadChromeVoxExtension(profile_, login_web_ui);
   chrome_vox_loaded_on_user_screen_ = true;
 }
 
 void AccessibilityManager::LoadChromeVoxToLockScreen() {
   if (chrome_vox_loaded_on_lock_screen_)
     return;
 
@@ skipping 163 matching lines @@
     pref_change_registrar_->Init(profile->GetPrefs());
     pref_change_registrar_->Add(
         prefs::kLargeCursorEnabled,
         base::Bind(&AccessibilityManager::UpdateLargeCursorFromPref,
                    base::Unretained(this)));
     pref_change_registrar_->Add(
         prefs::kStickyKeysEnabled,
         base::Bind(&AccessibilityManager::UpdateStickyKeysFromPref,
                    base::Unretained(this)));
     pref_change_registrar_->Add(
-        prefs::kSpokenFeedbackEnabled,
-        base::Bind(&AccessibilityManager::UpdateSpokenFeedbackFromPref,
-                   base::Unretained(this)));
-    pref_change_registrar_->Add(
         prefs::kHighContrastEnabled,
         base::Bind(&AccessibilityManager::UpdateHighContrastFromPref,
                    base::Unretained(this)));
     pref_change_registrar_->Add(
         prefs::kAutoclickEnabled,
         base::Bind(&AccessibilityManager::UpdateAutoclickFromPref,
                    base::Unretained(this)));
     pref_change_registrar_->Add(
         prefs::kAutoclickDelayMs,
         base::Bind(&AccessibilityManager::UpdateAutoclickDelayFromPref,
                    base::Unretained(this)));
 
     local_state_pref_change_registrar_.reset(new PrefChangeRegistrar);
     local_state_pref_change_registrar_->Init(g_browser_process->local_state());
     local_state_pref_change_registrar_->Add(
+        prefs::kSpokenFeedbackEnabled,
+        base::Bind(&AccessibilityManager::UpdateSpokenFeedbackFromPref,
+                   base::Unretained(this)));
+    local_state_pref_change_registrar_->Add(
         prefs::kApplicationLocale,
         base::Bind(&AccessibilityManager::LocalePrefChanged,
                    base::Unretained(this)));
 
     content::BrowserAccessibilityState::GetInstance()->AddHistogramCallback(
         base::Bind(
             &AccessibilityManager::UpdateChromeOSAccessibilityHistograms,
             base::Unretained(this)));
   }
 
   large_cursor_pref_handler_.HandleProfileChanged(profile_, profile);
-  spoken_feedback_pref_handler_.HandleProfileChanged(profile_, profile);
   high_contrast_pref_handler_.HandleProfileChanged(profile_, profile);
   autoclick_pref_handler_.HandleProfileChanged(profile_, profile);
   autoclick_delay_pref_handler_.HandleProfileChanged(profile_, profile);
 
   if (profile && spoken_feedback_enabled_)
     SetUpPreLoadChromeVox(profile);
 
   if (!profile_ && profile)
     CheckBrailleState();
 
@@ skipping 108 matching lines @@
     case chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED: {
       bool is_screen_locked = *content::Details<bool>(details).ptr();
       if (spoken_feedback_enabled_) {
         if (is_screen_locked) {
           LoadChromeVoxToLockScreen();
 
           // Status tray gets verbalized by user screen ChromeVox, so we need
           // this as well.
           LoadChromeVoxToUserScreen();
         } else {
-          // Lock screen destroys its resources; no need for us to explicitly
-          // unload ChromeVox.
-          chrome_vox_loaded_on_lock_screen_ = false;
-
-          // However, if spoken feedback was enabled, also enable it on the user
-          // screen.
+          // If spoken feedback was enabled, also enable it on the user screen.
           LoadChromeVoxToUserScreen();
         }
       }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       extensions::UnloadedExtensionInfo* info =
           content::Details<extensions::UnloadedExtensionInfo>(details).ptr();
       const extensions::Extension* extension = info->extension;
       if (extension->id() == extension_misc::kChromeVoxExtensionId) {
@@ skipping 68 matching lines @@
         event_router()->UnregisterObserver(this);
     chromevox_profiles_.erase(profile);
   }
 }
 
 void AccessibilityManager::PlaySound(int sound_key) const {
   media::SoundsManager::Get()->Play(sound_key);
 }
 
 }  // namespace chromeos