Remove USE_ATHENA ifdefs from chrome/browser/chromeos/accessibility

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/audio/sounds.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/session_state_delegate.h"
+#include "ash/shell.h"
+#include "ash/sticky_keys/sticky_keys_controller.h"
+#include "ash/system/tray/system_tray_notifier.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/accessibility/accessibility_extension_api.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/accessibility/magnification_manager.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/ui/accessibility_focus_ring_controller.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
@@ skipping 20 matching lines @@
 #include "extensions/browser/file_reader.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_resource.h"
 #include "media/audio/sounds/sounds_manager.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_util.h"
 
-#if !defined(USE_ATHENA)
-#include "ash/audio/sounds.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/session_state_delegate.h"
-#include "ash/shell.h"
-#include "ash/sticky_keys/sticky_keys_controller.h"
-#include "ash/system/tray/system_tray_notifier.h"
-#include "chrome/browser/chromeos/accessibility/magnification_manager.h"
-#endif
-
 using content::BrowserThread;
 using content::RenderViewHost;
 using extensions::api::braille_display_private::BrailleController;
 using extensions::api::braille_display_private::DisplayState;
 using extensions::api::braille_display_private::KeyEvent;
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 253 matching lines @@
       high_contrast_pref_handler_(prefs::kAccessibilityHighContrastEnabled),
       autoclick_pref_handler_(prefs::kAccessibilityAutoclickEnabled),
       autoclick_delay_pref_handler_(prefs::kAccessibilityAutoclickDelayMs),
       virtual_keyboard_pref_handler_(
           prefs::kAccessibilityVirtualKeyboardEnabled),
       large_cursor_enabled_(false),
       sticky_keys_enabled_(false),
       spoken_feedback_enabled_(false),
       high_contrast_enabled_(false),
       autoclick_enabled_(false),
-#if defined(USE_ATHENA)
-      autoclick_delay_ms_(400),
-#else
       autoclick_delay_ms_(ash::AutoclickController::kDefaultAutoclickDelayMs),
-#endif
       virtual_keyboard_enabled_(false),
       spoken_feedback_notification_(ui::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),
       weak_ptr_factory_(this) {
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
@@ skipping 54 matching lines @@
         pref_service->GetBoolean(prefs::kAccessibilityAutoclickEnabled) ||
         pref_service->GetBoolean(prefs::kShouldAlwaysShowAccessibilityMenu) ||
         pref_service->GetBoolean(prefs::kAccessibilityScreenMagnifierEnabled) ||
         pref_service->GetBoolean(prefs::kAccessibilityVirtualKeyboardEnabled))
       return true;
   }
   return false;
 }
 
 bool AccessibilityManager::ShouldEnableCursorCompositing() {
-#if defined(OS_CHROMEOS)
   if (!profile_)
     return false;
   PrefService* pref_service = profile_->GetPrefs();
   // Enable cursor compositing when one or more of the listed accessibility
   // features are turned on.
   if (pref_service->GetBoolean(prefs::kAccessibilityLargeCursorEnabled) ||
       pref_service->GetBoolean(prefs::kAccessibilityHighContrastEnabled) ||
       pref_service->GetBoolean(prefs::kAccessibilityScreenMagnifierEnabled))
     return true;
-#endif
   return false;
 }
 
 void AccessibilityManager::EnableLargeCursor(bool enabled) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetBoolean(prefs::kAccessibilityLargeCursorEnabled, enabled);
   pref_service->CommitPendingWrite();
@@ skipping 10 matching lines @@
     return;
 
   large_cursor_enabled_ = enabled;
 
   AccessibilityStatusEventDetails details(
       ACCESSIBILITY_TOGGLE_LARGE_CURSOR,
       enabled,
       ui::A11Y_NOTIFICATION_NONE);
 
   NotifyAccessibilityStatusChanged(details);
-#if !defined(USE_ATHENA)
-  // crbug.com/408733 (and for all USE_ATHENA in this file)
 
-#if defined(USE_ASH)
-  // Large cursor is implemented only in ash.
   ash::Shell::GetInstance()->cursor_manager()->SetCursorSet(
       enabled ? ui::CURSOR_SET_LARGE : ui::CURSOR_SET_NORMAL);
-#endif
-
-#if defined(OS_CHROMEOS)
   ash::Shell::GetInstance()->SetCursorCompositingEnabled(
       ShouldEnableCursorCompositing());
-#endif
-
-#endif // !USE_ATHENA
 }
 
 bool AccessibilityManager::IsIncognitoAllowed() {
   // Supervised users can't create incognito-mode windows.
   return !user_manager::UserManager::Get()->IsLoggedInAsSupervisedUser() &&
          !user_manager::UserManager::Get()->IsLoggedInAsChildUser();
 }
 
 bool AccessibilityManager::IsLargeCursorEnabled() {
   return large_cursor_enabled_;
@@ skipping 15 matching lines @@
   if (!profile_)
     return;
 
   const bool enabled =
       profile_->GetPrefs()->GetBoolean(prefs::kAccessibilityStickyKeysEnabled);
 
   if (sticky_keys_enabled_ == enabled)
     return;
 
   sticky_keys_enabled_ = enabled;
-#if defined(USE_ASH) && !defined(USE_ATHENA)
   ash::Shell::GetInstance()->sticky_keys_controller()->Enable(enabled);
-#endif
 }
 
 void AccessibilityManager::EnableSpokenFeedback(
     bool enabled,
     ui::AccessibilityNotificationVisibility notify) {
   if (!profile_)
     return;
-#if !defined(USE_ATHENA)
   ash::Shell::GetInstance()->metrics()->RecordUserMetricsAction(
       enabled ? ash::UMA_STATUS_AREA_ENABLE_SPOKEN_FEEDBACK
               : ash::UMA_STATUS_AREA_DISABLE_SPOKEN_FEEDBACK);
-#endif
 
   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;
 }
 
@@ skipping 139 matching lines @@
 
   high_contrast_enabled_ = enabled;
 
   AccessibilityStatusEventDetails details(
       ACCESSIBILITY_TOGGLE_HIGH_CONTRAST_MODE,
       enabled,
       ui::A11Y_NOTIFICATION_NONE);
 
   NotifyAccessibilityStatusChanged(details);
 
-#if !defined(USE_ATHENA)
-
-#if defined(USE_ASH)
   ash::Shell::GetInstance()->high_contrast_controller()->SetEnabled(enabled);
-#endif
-
-#if defined(OS_CHROMEOS)
   ash::Shell::GetInstance()->SetCursorCompositingEnabled(
       ShouldEnableCursorCompositing());
-#endif
-
-#endif
 }
 
 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);
 }
 
 void AccessibilityManager::PlayEarcon(int sound_key) {
-#if !defined(USE_ATHENA)
   DCHECK(sound_key < chromeos::SOUND_COUNT);
   ash::PlaySystemSoundIfSpokenFeedback(sound_key);
-#endif
 }
 
 bool AccessibilityManager::IsHighContrastEnabled() {
   return high_contrast_enabled_;
 }
 
 void AccessibilityManager::EnableAutoclick(bool enabled) {
   if (!profile_)
     return;
 
@@ skipping 10 matching lines @@
   if (!profile_)
     return;
 
   bool enabled =
       profile_->GetPrefs()->GetBoolean(prefs::kAccessibilityAutoclickEnabled);
 
   if (autoclick_enabled_ == enabled)
     return;
   autoclick_enabled_ = enabled;
 
-#if defined(USE_ASH) && !defined(USE_ATHENA)
   ash::Shell::GetInstance()->autoclick_controller()->SetEnabled(enabled);
-#endif
 }
 
 void AccessibilityManager::SetAutoclickDelay(int delay_ms) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetInteger(prefs::kAccessibilityAutoclickDelayMs, delay_ms);
   pref_service->CommitPendingWrite();
 }
 
 int AccessibilityManager::GetAutoclickDelay() const {
   return autoclick_delay_ms_;
 }
 
 void AccessibilityManager::UpdateAutoclickDelayFromPref() {
   if (!profile_)
     return;
 
   int autoclick_delay_ms =
       profile_->GetPrefs()->GetInteger(prefs::kAccessibilityAutoclickDelayMs);
 
   if (autoclick_delay_ms == autoclick_delay_ms_)
     return;
   autoclick_delay_ms_ = autoclick_delay_ms;
 
-#if defined(USE_ASH) && !defined(USE_ATHENA)
   ash::Shell::GetInstance()->autoclick_controller()->SetAutoclickDelay(
       autoclick_delay_ms_);
-#endif
 }
 
 void AccessibilityManager::EnableVirtualKeyboard(bool enabled) {
   if (!profile_)
     return;
 
   PrefService* pref_service = profile_->GetPrefs();
   pref_service->SetBoolean(prefs::kAccessibilityVirtualKeyboardEnabled,
                            enabled);
   pref_service->CommitPendingWrite();
 }
 
 bool AccessibilityManager::IsVirtualKeyboardEnabled() {
   return virtual_keyboard_enabled_;
 }
 
 void AccessibilityManager::UpdateVirtualKeyboardFromPref() {
   if (!profile_)
     return;
 
   const bool enabled = profile_->GetPrefs()->GetBoolean(
       prefs::kAccessibilityVirtualKeyboardEnabled);
 
   if (virtual_keyboard_enabled_ == enabled)
     return;
   virtual_keyboard_enabled_ = enabled;
 
-#if defined(USE_ASH) && !defined(USE_ATHENA)
   keyboard::SetAccessibilityKeyboardEnabled(enabled);
   // Note that there are two versions of the on-screen keyboard. A full layout
   // is provided for accessibility, which includes sticky modifier keys to
   // 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();
-#endif
 
   AccessibilityStatusEventDetails details(
       ACCESSIBILITY_TOGGLE_VIRTUAL_KEYBOARD,
       enabled,
       ui::A11Y_NOTIFICATION_NONE);
   NotifyAccessibilityStatusChanged(details);
 }
 
 bool AccessibilityManager::IsBrailleDisplayConnected() const {
   return braille_display_connected_;
@@ skipping 40 matching lines @@
     preload_engines.erase(it);
   pref_service->SetString(prefs::kLanguagePreloadEngines,
                           JoinString(preload_engines, ','));
   braille_ime_current_ = false;
 }
 
 // Overridden from InputMethodManager::Observer.
 void AccessibilityManager::InputMethodChanged(
     input_method::InputMethodManager* manager,
     bool show_message) {
-#if defined(USE_ASH) && !defined(USE_ATHENA)
   // Sticky keys is implemented only in ash.
   // TODO(dpolukhin): support Athena, crbug.com/408733.
   ash::Shell::GetInstance()->sticky_keys_controller()->SetModifiersEnabled(
       manager->IsISOLevel5ShiftUsedByCurrentInputMethod(),
       manager->IsAltGrUsedByCurrentInputMethod());
-#endif
   const chromeos::input_method::InputMethodDescriptor descriptor =
       manager->GetActiveIMEState()->GetCurrentInputMethod();
   braille_ime_current_ =
       (descriptor.id() == extension_misc::kBrailleImeEngineId);
 }
 
 void AccessibilityManager::SetProfile(Profile* profile) {
   pref_change_registrar_.reset();
   local_state_pref_change_registrar_.reset();
 
@@ skipping 59 matching lines @@
     UpdateBrailleImeState();
   UpdateLargeCursorFromPref();
   UpdateStickyKeysFromPref();
   UpdateSpokenFeedbackFromPref();
   UpdateHighContrastFromPref();
   UpdateAutoclickFromPref();
   UpdateAutoclickDelayFromPref();
   UpdateVirtualKeyboardFromPref();
 }
 
-#if !defined(USE_ATHENA)
 void AccessibilityManager::ActiveUserChanged(const std::string& user_id) {
   SetProfile(ProfileManager::GetActiveUserProfile());
 }
-#endif
 
 void AccessibilityManager::SetProfileForTest(Profile* profile) {
   SetProfile(profile);
 }
 
 void AccessibilityManager::SetBrailleControllerForTest(
     BrailleController* controller) {
   g_braille_controller_for_test = controller;
 }
 
 void AccessibilityManager::EnableSystemSounds(bool system_sounds_enabled) {
   system_sounds_enabled_ = system_sounds_enabled;
 }
 
 base::TimeDelta AccessibilityManager::PlayShutdownSound() {
   if (!system_sounds_enabled_)
     return base::TimeDelta();
   system_sounds_enabled_ = false;
-#if !defined(USE_ATHENA)
   if (!ash::PlaySystemSoundIfSpokenFeedback(SOUND_SHUTDOWN))
     return base::TimeDelta();
-#endif
   return media::SoundsManager::Get()->GetDuration(SOUND_SHUTDOWN);
 }
 
 void AccessibilityManager::InjectChromeVox(RenderViewHost* render_view_host) {
   LoadChromeVoxExtension(profile_, render_view_host, base::Closure());
 }
 
 scoped_ptr<AccessibilityStatusSubscription>
     AccessibilityManager::RegisterCallback(
         const AccessibilityStatusCallback& cb) {
   return callback_list_.Add(cb);
 }
 
 void AccessibilityManager::NotifyAccessibilityStatusChanged(
     AccessibilityStatusEventDetails& details) {
   callback_list_.Notify(details);
 }
 
 void AccessibilityManager::UpdateChromeOSAccessibilityHistograms() {
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosSpokenFeedback",
                         IsSpokenFeedbackEnabled());
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosHighContrast",
                         IsHighContrastEnabled());
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosVirtualKeyboard",
                         IsVirtualKeyboardEnabled());
   UMA_HISTOGRAM_BOOLEAN("Accessibility.CrosStickyKeys", IsStickyKeysEnabled());
-#if !defined(USE_ATHENA)
   if (MagnificationManager::Get()) {
     uint32 type = MagnificationManager::Get()->IsMagnifierEnabled() ?
                       MagnificationManager::Get()->GetMagnifierType() : 0;
     // '0' means magnifier is disabled.
     UMA_HISTOGRAM_ENUMERATION("Accessibility.CrosScreenMagnifier",
                               type,
                               ui::kMaxMagnifierType + 1);
   }
-#endif
   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));
 
     bool autoclick_enabled =
@@ skipping 25 matching lines @@
         SetProfile(profile);
       break;
     }
     case chrome::NOTIFICATION_SESSION_STARTED:
       // Update |profile_| when entering a session.
       SetProfile(ProfileManager::GetActiveUserProfile());
 
       // Ensure ChromeVox makes announcements at the start of new sessions.
       should_speak_chrome_vox_announcements_on_user_screen_ = true;
 
-#if !defined(USE_ATHENA)
       // Add a session state observer to be able to monitor session changes.
       if (!session_state_observer_.get() && ash::Shell::HasInstance())
         session_state_observer_.reset(
             new ash::ScopedSessionStateObserver(this));
-#endif
       break;
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       // Update |profile_| when exiting a session or shutting down.
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile_ == profile)
         SetProfile(NULL);
       break;
     }
     case chrome::NOTIFICATION_SCREEN_LOCK_STATE_CHANGED: {
       bool is_screen_locked = *content::Details<bool>(details).ptr();
@@ skipping 32 matching lines @@
        extensions::api::braille_display_private::KEY_COMMAND_DOTS) &&
       !braille_ime_current_) {
     input_method::InputMethodManager::Get()
         ->GetActiveIMEState()
         ->ChangeInputMethod(extension_misc::kBrailleImeEngineId,
                             false /* show_message */);
   }
 }
 
 void AccessibilityManager::PostLoadChromeVox(Profile* profile) {
-#if !defined(USE_ATHENA)
   // Do any setup work needed immediately after ChromeVox actually loads.
   if (system_sounds_enabled_)
     ash::PlaySystemSoundAlways(SOUND_SPOKEN_FEEDBACK_ENABLED);
-#endif
 
   ExtensionAccessibilityEventRouter::GetInstance()->
       OnChromeVoxLoadStateChanged(profile_,
           IsSpokenFeedbackEnabled(),
           chrome_vox_loaded_on_lock_screen_ ||
               should_speak_chrome_vox_announcements_on_user_screen_);
 
   should_speak_chrome_vox_announcements_on_user_screen_ =
       chrome_vox_loaded_on_lock_screen_;
 }
 
 void AccessibilityManager::PostUnloadChromeVox(Profile* profile) {
-#if !defined(USE_ATHENA)
   // Do any teardown work needed immediately after ChromeVox actually unloads.
   if (system_sounds_enabled_)
     ash::PlaySystemSoundAlways(SOUND_SPOKEN_FEEDBACK_DISABLED);
-#endif
   // Clear the accessibility focus ring.
   AccessibilityFocusRingController::GetInstance()->SetFocusRing(
       std::vector<gfx::Rect>());
 }
 
 }  // namespace chromeos