mash: Move accessibility_types.h from ui namespace to ash namespace

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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 297 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ChromeVoxPanelWidgetObserver);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // AccessibilityStatusEventDetails
 
 AccessibilityStatusEventDetails::AccessibilityStatusEventDetails(
     AccessibilityNotificationType notification_type,
     bool enabled,
-    ui::AccessibilityNotificationVisibility notify)
-  : notification_type(notification_type),
-    enabled(enabled),
-    magnifier_type(ui::kDefaultMagnifierType),
-    notify(notify) {}
+    ash::AccessibilityNotificationVisibility notify)
+    : notification_type(notification_type),
+      enabled(enabled),
+      magnifier_type(ash::kDefaultMagnifierType),
+      notify(notify) {}
 
 AccessibilityStatusEventDetails::AccessibilityStatusEventDetails(
     AccessibilityNotificationType notification_type,
     bool enabled,
-    ui::MagnifierType magnifier_type,
-    ui::AccessibilityNotificationVisibility notify)
-  : notification_type(notification_type),
-    enabled(enabled),
-    magnifier_type(magnifier_type),
-    notify(notify) {}
+    ash::MagnifierType magnifier_type,
+    ash::AccessibilityNotificationVisibility notify)
+    : notification_type(notification_type),
+      enabled(enabled),
+      magnifier_type(magnifier_type),
+      notify(notify) {}
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // AccessibilityManager::PrefHandler
 
 AccessibilityManager::PrefHandler::PrefHandler(const char* pref_path)
     : pref_path_(pref_path) {}
 
 AccessibilityManager::PrefHandler::~PrefHandler() {}
 
@@ skipping 53 matching lines @@
     : profile_(NULL),
       chrome_vox_loaded_on_lock_screen_(false),
       chrome_vox_loaded_on_user_screen_(false),
       large_cursor_pref_handler_(prefs::kAccessibilityLargeCursorEnabled),
       spoken_feedback_pref_handler_(prefs::kAccessibilitySpokenFeedbackEnabled),
       high_contrast_pref_handler_(prefs::kAccessibilityHighContrastEnabled),
       autoclick_pref_handler_(prefs::kAccessibilityAutoclickEnabled),
       autoclick_delay_pref_handler_(prefs::kAccessibilityAutoclickDelayMs),
       virtual_keyboard_pref_handler_(
           prefs::kAccessibilityVirtualKeyboardEnabled),
-      mono_audio_pref_handler_(
-          prefs::kAccessibilityMonoAudioEnabled),
+      mono_audio_pref_handler_(prefs::kAccessibilityMonoAudioEnabled),
       caret_highlight_pref_handler_(prefs::kAccessibilityCaretHighlightEnabled),
       cursor_highlight_pref_handler_(
           prefs::kAccessibilityCursorHighlightEnabled),
       focus_highlight_pref_handler_(prefs::kAccessibilityFocusHighlightEnabled),
       select_to_speak_pref_handler_(prefs::kAccessibilitySelectToSpeakEnabled),
       switch_access_pref_handler_(prefs::kAccessibilitySwitchAccessEnabled),
       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),
       virtual_keyboard_enabled_(false),
       mono_audio_enabled_(false),
       caret_highlight_enabled_(false),
       cursor_highlight_enabled_(false),
       focus_highlight_enabled_(false),
       select_to_speak_enabled_(false),
       switch_access_enabled_(false),
-      spoken_feedback_notification_(ui::A11Y_NOTIFICATION_NONE),
+      spoken_feedback_notification_(ash::A11Y_NOTIFICATION_NONE),
       should_speak_chrome_vox_announcements_on_user_screen_(true),
       system_sounds_enabled_(false),
       braille_display_connected_(false),
       scoped_braille_observer_(this),
       braille_ime_current_(false),
       chromevox_panel_(nullptr),
       extension_registry_observer_(this),
       weak_ptr_factory_(this) {
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
@@ skipping 23 matching lines @@
   manager->Initialize(SOUND_PASSTHROUGH,
                       bundle.GetRawDataResource(IDR_SOUND_PASSTHROUGH_WAV));
   manager->Initialize(SOUND_EXIT_SCREEN,
                       bundle.GetRawDataResource(IDR_SOUND_EXIT_SCREEN_WAV));
   manager->Initialize(SOUND_ENTER_SCREEN,
                       bundle.GetRawDataResource(IDR_SOUND_ENTER_SCREEN_WAV));
 }
 
 AccessibilityManager::~AccessibilityManager() {
   CHECK(this == g_accessibility_manager);
-  AccessibilityStatusEventDetails details(
-      ACCESSIBILITY_MANAGER_SHUTDOWN,
-      false,
-      ui::A11Y_NOTIFICATION_NONE);
+  AccessibilityStatusEventDetails details(ACCESSIBILITY_MANAGER_SHUTDOWN, false,
+                                          ash::A11Y_NOTIFICATION_NONE);
   NotifyAccessibilityStatusChanged(details);
   input_method::InputMethodManager::Get()->RemoveObserver(this);
 
   if (chromevox_panel_) {
     chromevox_panel_->Close();
     chromevox_panel_ = nullptr;
   }
 }
 
 bool AccessibilityManager::ShouldShowAccessibilityMenu() {
@@ skipping 46 matching lines @@
     return;
 
   const bool enabled =
       profile_->GetPrefs()->GetBoolean(prefs::kAccessibilityLargeCursorEnabled);
 
   if (large_cursor_enabled_ == enabled)
     return;
 
   large_cursor_enabled_ = enabled;
 
-  AccessibilityStatusEventDetails details(
-      ACCESSIBILITY_TOGGLE_LARGE_CURSOR,
-      enabled,
-      ui::A11Y_NOTIFICATION_NONE);
+  AccessibilityStatusEventDetails details(ACCESSIBILITY_TOGGLE_LARGE_CURSOR,
+                                          enabled, ash::A11Y_NOTIFICATION_NONE);
 
   NotifyAccessibilityStatusChanged(details);
 
   ash::Shell::GetInstance()->cursor_manager()->SetCursorSet(
       enabled ? ui::CURSOR_SET_LARGE : ui::CURSOR_SET_NORMAL);
   ash::Shell::GetInstance()->SetCursorCompositingEnabled(
       ShouldEnableCursorCompositing());
 }
 
 bool AccessibilityManager::IsIncognitoAllowed() {
@@ skipping 28 matching lines @@
 
   if (sticky_keys_enabled_ == enabled)
     return;
 
   sticky_keys_enabled_ = enabled;
   ash::Shell::GetInstance()->sticky_keys_controller()->Enable(enabled);
 }
 
 void AccessibilityManager::EnableSpokenFeedback(
     bool enabled,
-    ui::AccessibilityNotificationVisibility notify) {
+    ash::AccessibilityNotificationVisibility notify) {
   if (!profile_)
     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::kAccessibilitySpokenFeedbackEnabled, enabled);
   pref_service->CommitPendingWrite();
 
-  spoken_feedback_notification_ = ui::A11Y_NOTIFICATION_NONE;
+  spoken_feedback_notification_ = ash::A11Y_NOTIFICATION_NONE;
 }
 
 void AccessibilityManager::UpdateSpokenFeedbackFromPref() {
   if (!profile_)
     return;
 
   const bool enabled = profile_->GetPrefs()->GetBoolean(
       prefs::kAccessibilitySpokenFeedbackEnabled);
 
   if (spoken_feedback_enabled_ == enabled)
@@ skipping 104 matching lines @@
   Profile* signin_profile = ProfileHelper::GetSigninProfile();
   UnloadChromeVoxExtension(signin_profile);
   chrome_vox_loaded_on_lock_screen_ = false;
 }
 
 bool AccessibilityManager::IsSpokenFeedbackEnabled() {
   return spoken_feedback_enabled_;
 }
 
 void AccessibilityManager::ToggleSpokenFeedback(
-    ui::AccessibilityNotificationVisibility notify) {
+    ash::AccessibilityNotificationVisibility notify) {
   EnableSpokenFeedback(!IsSpokenFeedbackEnabled(), notify);
 }
 
 void AccessibilityManager::EnableHighContrast(bool enabled) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetBoolean(prefs::kAccessibilityHighContrastEnabled, enabled);
   pref_service->CommitPendingWrite();
 }
 
 void AccessibilityManager::UpdateHighContrastFromPref() {
   if (!profile_)
     return;
 
   const bool enabled = profile_->GetPrefs()->GetBoolean(
       prefs::kAccessibilityHighContrastEnabled);
 
   if (high_contrast_enabled_ == enabled)
     return;
 
   high_contrast_enabled_ = enabled;
 
   AccessibilityStatusEventDetails details(
-      ACCESSIBILITY_TOGGLE_HIGH_CONTRAST_MODE,
-      enabled,
-      ui::A11Y_NOTIFICATION_NONE);
+      ACCESSIBILITY_TOGGLE_HIGH_CONTRAST_MODE, enabled,
+      ash::A11Y_NOTIFICATION_NONE);
 
   NotifyAccessibilityStatusChanged(details);
 
   ash::Shell::GetInstance()->high_contrast_controller()->SetEnabled(enabled);
   ash::Shell::GetInstance()->SetCursorCompositingEnabled(
       ShouldEnableCursorCompositing());
 }
 
 void AccessibilityManager::OnLocaleChanged() {
   if (!profile_)
     return;
 
   if (!IsSpokenFeedbackEnabled())
     return;
 
   // If the system locale changes and spoken feedback is enabled,
   // reload ChromeVox so that it switches its internal translations
   // to the new language.
-  EnableSpokenFeedback(false, ui::A11Y_NOTIFICATION_NONE);
-  EnableSpokenFeedback(true, ui::A11Y_NOTIFICATION_NONE);
+  EnableSpokenFeedback(false, ash::A11Y_NOTIFICATION_NONE);
+  EnableSpokenFeedback(true, ash::A11Y_NOTIFICATION_NONE);
 }
 
 void AccessibilityManager::PlayEarcon(int sound_key) {
   DCHECK(sound_key < chromeos::SOUND_COUNT);
   ash::PlaySystemSoundIfSpokenFeedback(sound_key);
 }
 
 void AccessibilityManager::HandleAccessibilityGesture(ui::AXGesture gesture) {
   extensions::EventRouter* event_router =
       extensions::EventRouter::Get(profile());
@@ skipping 107 matching lines @@
   // enable typing of hotkeys. A compact version is used in touchview mode
   // to provide a layout with larger keys to facilitate touch typing. In the
   // event that the a11y keyboard is being disabled, an on-screen keyboard might
   // still be enabled and a forced reset is required to pick up the layout
   // change.
   if (keyboard::IsKeyboardEnabled())
     ash::Shell::GetInstance()->CreateKeyboard();
   else
     ash::Shell::GetInstance()->DeactivateKeyboard();
 
-  AccessibilityStatusEventDetails details(
-      ACCESSIBILITY_TOGGLE_VIRTUAL_KEYBOARD,
-      enabled,
-      ui::A11Y_NOTIFICATION_NONE);
+  AccessibilityStatusEventDetails details(ACCESSIBILITY_TOGGLE_VIRTUAL_KEYBOARD,
+                                          enabled, ash::A11Y_NOTIFICATION_NONE);
   NotifyAccessibilityStatusChanged(details);
 }
 
 void AccessibilityManager::EnableMonoAudio(bool enabled) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetBoolean(prefs::kAccessibilityMonoAudioEnabled,
                            enabled);
   pref_service->CommitPendingWrite();
 }
 
 bool AccessibilityManager::IsMonoAudioEnabled() {
   return mono_audio_enabled_;
 }
 
 void AccessibilityManager::UpdateMonoAudioFromPref() {
   if (!profile_)
     return;
 
   const bool enabled = profile_->GetPrefs()->GetBoolean(
       prefs::kAccessibilityMonoAudioEnabled);
 
   if (mono_audio_enabled_ == enabled)
     return;
   mono_audio_enabled_ = enabled;
 
-  AccessibilityStatusEventDetails details(
-      ACCESSIBILITY_TOGGLE_MONO_AUDIO,
-      enabled,
-      ui::A11Y_NOTIFICATION_NONE);
+  AccessibilityStatusEventDetails details(ACCESSIBILITY_TOGGLE_MONO_AUDIO,
+                                          enabled, ash::A11Y_NOTIFICATION_NONE);
   NotifyAccessibilityStatusChanged(details);
 
   ash::Shell::GetInstance()->audio_a11y_controller()->SetOutputMono(enabled);
 }
 
 void AccessibilityManager::SetCaretHighlightEnabled(bool enabled) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
@@ skipping 387 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosHighContrast",
                         IsHighContrastEnabled());
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosVirtualKeyboard",
                         IsVirtualKeyboardEnabled());
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosStickyKeys", IsStickyKeysEnabled());
   if (MagnificationManager::Get()) {
     uint32_t type = MagnificationManager::Get()->IsMagnifierEnabled()
                         ? MagnificationManager::Get()->GetMagnifierType()
                         : 0;
     // '0' means magnifier is disabled.
-    UMA_HISTOGRAM_ENUMERATION("Accessibility.CrosScreenMagnifier",
-                              type,
-                              ui::kMaxMagnifierType + 1);
+    UMA_HISTOGRAM_ENUMERATION("Accessibility.CrosScreenMagnifier", type,
+                              ash::kMaxMagnifierType + 1);
   }
   if (profile_) {
     const PrefService* const prefs = profile_->GetPrefs();
     UMA_HISTOGRAM_BOOLEAN(
         "Accessibility.CrosLargeCursor",
         prefs->GetBoolean(prefs::kAccessibilityLargeCursorEnabled));
     UMA_HISTOGRAM_BOOLEAN(
         "Accessibility.CrosAlwaysShowA11yMenu",
         prefs->GetBoolean(prefs::kShouldAlwaysShowAccessibilityMenu));
 
@@ skipping 68 matching lines @@
       }
       break;
     }
   }
 }
 
 void AccessibilityManager::OnBrailleDisplayStateChanged(
     const DisplayState& display_state) {
   braille_display_connected_ = display_state.available;
   if (braille_display_connected_) {
-    EnableSpokenFeedback(true, ui::A11Y_NOTIFICATION_SHOW);
+    EnableSpokenFeedback(true, ash::A11Y_NOTIFICATION_SHOW);
   }
   UpdateBrailleImeState();
 
   AccessibilityStatusEventDetails details(
       ACCESSIBILITY_BRAILLE_DISPLAY_CONNECTION_STATE_CHANGED,
-      braille_display_connected_,
-      ui::A11Y_NOTIFICATION_SHOW);
+      braille_display_connected_, ash::A11Y_NOTIFICATION_SHOW);
   NotifyAccessibilityStatusChanged(details);
 }
 
 void AccessibilityManager::OnBrailleKeyEvent(const KeyEvent& event) {
   // Ensure the braille IME is active on braille keyboard (dots) input.
   if ((event.command ==
        extensions::api::braille_display_private::KEY_COMMAND_DOTS) &&
       !braille_ime_current_) {
     input_method::InputMethodManager::Get()
         ->GetActiveIMEState()
@@ skipping 81 matching lines @@
     content::BrowserContext* context) {
   keyboard_listener_extension_id_ = id;
 
   extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(context);
   if (!extension_registry_observer_.IsObserving(registry) && !id.empty())
     extension_registry_observer_.Add(registry);
 }
 
 }  // namespace chromeos