cros: Remove some OS platform ifdefs from ash

ash/shell.cc

 // Copyright (c) 2012 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 "ash/shell.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "ash/accelerators/accelerator_controller_delegate_aura.h"
 #include "ash/accelerators/accelerator_delegate.h"
+#include "ash/accelerators/magnifier_key_scroller.h"
+#include "ash/accelerators/spoken_feedback_toggler.h"
 #include "ash/aura/wm_shell_aura.h"
 #include "ash/aura/wm_window_aura.h"
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/common/accelerators/accelerator_controller.h"
+#include "ash/common/ash_constants.h"
 #include "ash/common/frame/custom_frame_view_ash.h"
 #include "ash/common/gpu_support.h"
 #include "ash/common/keyboard/keyboard_ui.h"
 #include "ash/common/login_status.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/app_list_shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/shelf_item_delegate.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_delegate.h"
+#include "ash/common/system/chromeos/bluetooth/bluetooth_notification_controller.h"
+#include "ash/common/system/chromeos/power/power_status.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wallpaper/wallpaper_delegate.h"
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/common/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/common/wm/mru_window_tracker.h"
 #include "ash/common/wm/root_window_finder.h"
 #include "ash/common/wm/system_modal_container_layout_manager.h"
 #include "ash/common/wm/window_positioner.h"
 #include "ash/common/wm/workspace_controller.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/cursor_window_controller.h"
+#include "ash/display/display_color_manager_chromeos.h"
 #include "ash/display/display_configuration_controller.h"
+#include "ash/display/display_error_observer_chromeos.h"
 #include "ash/display/event_transformation_handler.h"
 #include "ash/display/mouse_cursor_event_filter.h"
+#include "ash/display/projecting_observer_chromeos.h"
+#include "ash/display/resolution_notification_controller.h"
 #include "ash/display/screen_ash.h"
+#include "ash/display/screen_orientation_controller_chromeos.h"
 #include "ash/display/screen_position_controller.h"
+#include "ash/display/shutdown_observer_chromeos.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/drag_drop/drag_drop_controller.h"
 #include "ash/first_run/first_run_helper_impl.h"
 #include "ash/high_contrast/high_contrast_controller.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/ime/input_method_event_handler.h"
 #include "ash/laser/laser_pointer_controller.h"
 #include "ash/magnifier/magnification_controller.h"
 #include "ash/magnifier/partial_magnification_controller.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell_init_params.h"
+#include "ash/sticky_keys/sticky_keys_controller.h"
+#include "ash/system/chromeos/power/power_event_observer.h"
+#include "ash/system/chromeos/power/video_activity_notifier.h"
 #include "ash/system/chromeos/screen_layout_observer.h"
+#include "ash/touch/touch_transformer_controller.h"
 #include "ash/utility/screenshot_controller.h"
+#include "ash/virtual_keyboard_controller.h"
 #include "ash/wm/ash_focus_rules.h"
 #include "ash/wm/ash_native_cursor_manager.h"
 #include "ash/wm/event_client_impl.h"
 #include "ash/wm/immersive_handler_factory_ash.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/overlay_event_filter.h"
 #include "ash/wm/overview/scoped_overview_animation_settings_factory_aura.h"
 #include "ash/wm/power_button_controller.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/screen_pinning_controller.h"
 #include "ash/wm/system_gesture_event_filter.h"
 #include "ash/wm/system_modal_container_event_filter.h"
 #include "ash/wm/toplevel_window_event_handler.h"
 #include "ash/wm/video_detector.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
+#include "chromeos/audio/audio_a11y_controller.h"
+#include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/user_activity/user_activity_detector.h"
+#include "ui/chromeos/user_activity_power_manager_notifier.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/display/display.h"
+#include "ui/display/manager/chromeos/display_change_observer.h"
+#include "ui/display/manager/chromeos/display_configurator.h"
 #include "ui/display/manager/display_manager.h"
 #include "ui/display/screen.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/message_center/message_center.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/corewm/tooltip_controller.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/accelerator_filter.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_modality_controller.h"
 
-#if defined(OS_CHROMEOS)
-#if defined(USE_X11)
-#include "ui/gfx/x/x11_types.h"  // nogncheck
-#endif                           // defined(USE_X11)
-#include "ash/accelerators/magnifier_key_scroller.h"
-#include "ash/accelerators/spoken_feedback_toggler.h"
-#include "ash/common/ash_constants.h"
-#include "ash/common/system/chromeos/bluetooth/bluetooth_notification_controller.h"
-#include "ash/common/system/chromeos/power/power_status.h"
-#include "ash/display/display_color_manager_chromeos.h"
-#include "ash/display/display_error_observer_chromeos.h"
-#include "ash/display/projecting_observer_chromeos.h"
-#include "ash/display/resolution_notification_controller.h"
-#include "ash/display/screen_orientation_controller_chromeos.h"
-#include "ash/display/shutdown_observer_chromeos.h"
-#include "ash/sticky_keys/sticky_keys_controller.h"
-#include "ash/system/chromeos/power/power_event_observer.h"
-#include "ash/system/chromeos/power/video_activity_notifier.h"
-#include "ash/touch/touch_transformer_controller.h"
-#include "ash/virtual_keyboard_controller.h"
-#include "base/bind_helpers.h"
-#include "base/sys_info.h"
-#include "chromeos/audio/audio_a11y_controller.h"
-#include "chromeos/chromeos_switches.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
-#include "ui/chromeos/user_activity_power_manager_notifier.h"
-#include "ui/display/manager/chromeos/display_change_observer.h"
-#include "ui/display/manager/chromeos/display_configurator.h"
-
 #if defined(USE_X11)
 #include "ui/display/manager/chromeos/x11/native_display_delegate_x11.h"
+#include "ui/gfx/x/x11_types.h"  // nogncheck
 #endif
 
 #if defined(USE_OZONE)
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
-#endif  // defined(OS_CHROMEOS)
 
 namespace ash {
 
 namespace {
 
 using aura::Window;
 using views::Widget;
 
 // A Corewm VisibilityController subclass that calls the Ash animation routine
 // so we can pick up our extended animations. See ash/wm/window_animations.h.
@@ skipping 130 matching lines @@
     std::vector<WmWindow*> containers = wm::GetContainersFromAllRootWindows(
         kShellWindowId_LockSystemModalContainer,
         WmWindowAura::Get(GetPrimaryRootWindow()));
     for (WmWindow* container : containers)
       DCHECK(container->GetChildren().empty());
   }
 #endif
 }
 
 void Shell::OnCastingSessionStartedOrStopped(bool started) {
-#if defined(OS_CHROMEOS)
   for (auto& observer : *wm_shell_->shell_observers())
     observer.OnCastingSessionStartedOrStopped(started);
-#endif
 }
 
 void Shell::OnRootWindowAdded(WmWindow* root_window) {
   for (auto& observer : *wm_shell_->shell_observers())
     observer.OnRootWindowAdded(root_window);
 }
 
 void Shell::CreateKeyboard() {
   InitKeyboard();
   GetPrimaryRootWindowController()->ActivateKeyboard(
       keyboard::KeyboardController::GetInstance());
 }
 
 void Shell::DeactivateKeyboard() {
   // TODO(jamescook): Move keyboard create and hide into WmShell.
   wm_shell_->keyboard_ui()->Hide();
   if (keyboard::KeyboardController::GetInstance()) {
     RootWindowControllerList controllers = GetAllRootWindowControllers();
     for (RootWindowControllerList::iterator iter = controllers.begin();
          iter != controllers.end(); ++iter) {
       (*iter)->DeactivateKeyboard(keyboard::KeyboardController::GetInstance());
     }
   }
   keyboard::KeyboardController::ResetInstance(nullptr);
 }
 
-#if defined(OS_CHROMEOS)
 bool Shell::ShouldSaveDisplaySettings() {
   return !(
       screen_orientation_controller_->ignore_display_configuration_updates() ||
       resolution_notification_controller_->DoesNotificationTimeout());
 }
-#endif
 
 void Shell::UpdateShelfVisibility() {
   for (WmWindow* root : wm_shell_->GetAllRootWindows())
     root->GetRootWindowController()->GetShelf()->UpdateVisibilityState();
 }
 
 WebNotificationTray* Shell::GetWebNotificationTray() {
   return GetPrimaryRootWindowController()
       ->GetStatusAreaWidget()
       ->web_notification_tray();
 }
 
 bool Shell::HasPrimaryStatusArea() {
   return !!GetPrimaryRootWindowController()->GetStatusAreaWidget();
 }
 
 SystemTray* Shell::GetPrimarySystemTray() {
   return GetPrimaryRootWindowController()->GetSystemTray();
 }
 
 void Shell::SetTouchHudProjectionEnabled(bool enabled) {
   if (is_touch_hud_projection_enabled_ == enabled)
     return;
 
   is_touch_hud_projection_enabled_ = enabled;
   for (auto& observer : *wm_shell_->shell_observers())
     observer.OnTouchHudProjectionToggled(enabled);
 }
 
-#if defined(OS_CHROMEOS)
 FirstRunHelper* Shell::CreateFirstRunHelper() {
   return new FirstRunHelperImpl;
 }
 
 void Shell::SetCursorCompositingEnabled(bool enabled) {
   window_tree_host_manager_->cursor_window_controller()
       ->SetCursorCompositingEnabled(enabled);
   native_cursor_manager_->SetNativeCursorEnabled(!enabled);
 }
-#endif  // defined(OS_CHROMEOS)
 
 void Shell::DoInitialWorkspaceAnimation() {
   return GetPrimaryRootWindowController()
       ->workspace_controller()
       ->DoInitialAnimation();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(ShellDelegate* delegate)
     : wm_shell_(new WmShellAura(base::WrapUnique(delegate))),
       link_handler_model_factory_(nullptr),
       activation_client_(nullptr),
-#if defined(OS_CHROMEOS)
       display_configurator_(new display::DisplayConfigurator()),
-#endif  // defined(OS_CHROMEOS)
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false) {
   DCHECK(aura::Env::GetInstanceDontCreate());
   gpu_support_.reset(wm_shell_->delegate()->CreateGPUSupport());
   display_manager_.reset(ScreenAsh::CreateDisplayManager());
   window_tree_host_manager_.reset(new WindowTreeHostManager);
   user_metrics_recorder_.reset(new UserMetricsRecorder);
 
-#if defined(OS_CHROMEOS)
   PowerStatus::Initialize();
-#endif
 }
 
 Shell::~Shell() {
   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
 
   user_metrics_recorder_->OnShellShuttingDown();
 
   wm_shell_->delegate()->PreShutdown();
 
   // Remove the focus from any window. This will prevent overhead and side
   // effects (e.g. crashes) from changing focus during shutdown.
   // See bug crbug.com/134502.
   aura::client::GetFocusClient(GetPrimaryRootWindow())->FocusWindow(nullptr);
 
   // Please keep in same order as in Init() because it's easy to miss one.
   if (window_modality_controller_)
     window_modality_controller_.reset();
   RemovePreTargetHandler(
       window_tree_host_manager_->input_method_event_handler());
-#if defined(OS_CHROMEOS)
+
   RemovePreTargetHandler(magnifier_key_scroll_handler_.get());
   magnifier_key_scroll_handler_.reset();
 
   RemovePreTargetHandler(speech_feedback_handler_.get());
   speech_feedback_handler_.reset();
-#endif
+
   RemovePreTargetHandler(overlay_filter_.get());
   RemovePreTargetHandler(accelerator_filter_.get());
   RemovePreTargetHandler(event_transformation_handler_.get());
   RemovePreTargetHandler(toplevel_window_event_handler_.get());
   RemovePostTargetHandler(toplevel_window_event_handler_.get());
   RemovePreTargetHandler(system_gesture_filter_.get());
   RemovePreTargetHandler(mouse_cursor_filter_.get());
   RemovePreTargetHandler(modality_filter_.get());
 
   // TooltipController is deleted with the Shell so removing its references.
   RemovePreTargetHandler(tooltip_controller_.get());
 
-#if defined(OS_CHROMEOS)
   screen_orientation_controller_.reset();
   screen_layout_observer_.reset();
-#endif
 
-// Destroy the virtual keyboard controller before the maximize mode controller
-// since the latters destructor triggers events that the former is listening
-// to but no longer cares about.
-#if defined(OS_CHROMEOS)
+  // Destroy the virtual keyboard controller before the maximize mode controller
+  // since the latters destructor triggers events that the former is listening
+  // to but no longer cares about.
   virtual_keyboard_controller_.reset();
-#endif
 
   // Destroy maximize mode controller early on since it has some observers which
   // need to be removed.
   wm_shell_->DeleteMaximizeModeController();
 
   // Destroy the keyboard before closing the shelf, since it will invoke a shelf
   // layout.
   DeactivateKeyboard();
 
   // Destroy toasts
   wm_shell_->DeleteToastManager();
 
   // Destroy SystemTrayDelegate before destroying the status area(s). Make sure
   // to deinitialize the shelf first, as it is initialized after the delegate.
   for (WmWindow* root : wm_shell_->GetAllRootWindows())
     root->GetRootWindowController()->GetShelf()->ShutdownShelfWidget();
   wm_shell_->DeleteSystemTrayDelegate();
 
   // Drag-and-drop must be canceled prior to close all windows.
   drag_drop_controller_.reset();
 
 // Controllers who have WindowObserver added must be deleted
 // before |window_tree_host_manager_| is deleted.
 
-#if defined(OS_CHROMEOS)
   // VideoActivityNotifier must be deleted before |video_detector_| is
   // deleted because it's observing video activity through
   // VideoDetector::Observer interface.
   video_activity_notifier_.reset();
-#endif  // defined(OS_CHROMEOS)
   video_detector_.reset();
   high_contrast_controller_.reset();
 
   shadow_controller_.reset();
   resize_shadow_controller_.reset();
 
   // Has to happen before ~MruWindowTracker.
   wm_shell_->DeleteWindowCycleController();
   wm_shell_->DeleteWindowSelectorController();
 
@@ skipping 11 matching lines @@
   tooltip_controller_.reset();
   event_client_.reset();
   toplevel_window_event_handler_.reset();
   visibility_controller_.reset();
 
   power_button_controller_.reset();
   lock_state_controller_.reset();
 
   screen_pinning_controller_.reset();
 
-#if defined(OS_CHROMEOS)
   resolution_notification_controller_.reset();
-#endif
   screenshot_controller_.reset();
   mouse_cursor_filter_.reset();
   modality_filter_.reset();
 
-#if defined(OS_CHROMEOS)
   touch_transformer_controller_.reset();
   audio_a11y_controller_.reset();
   laser_pointer_controller_.reset();
   partial_magnification_controller_.reset();
-#endif  // defined(OS_CHROMEOS)
 
   // This also deletes all RootWindows. Note that we invoke Shutdown() on
   // WindowTreeHostManager before resetting |window_tree_host_manager_|, since
   // destruction
   // of its owned RootWindowControllers relies on the value.
   ScreenAsh::CreateScreenForShutdown();
   display_configuration_controller_.reset();
 
   wm_shell_->Shutdown();
   // Depends on |focus_client_|, so must be destroyed before.
   window_tree_host_manager_->Shutdown();
   window_tree_host_manager_.reset();
   focus_client_.reset();
   screen_position_controller_.reset();
 
   keyboard::KeyboardController::ResetInstance(nullptr);
 
-#if defined(OS_CHROMEOS)
   display_color_manager_.reset();
   if (display_change_observer_)
     display_configurator_->RemoveObserver(display_change_observer_.get());
   if (display_error_observer_)
     display_configurator_->RemoveObserver(display_error_observer_.get());
   if (projecting_observer_) {
     display_configurator_->RemoveObserver(projecting_observer_.get());
     wm_shell_->RemoveShellObserver(projecting_observer_.get());
   }
   display_change_observer_.reset();
   shutdown_observer_.reset();
 
   PowerStatus::Shutdown();
 
   // Ensure that DBusThreadManager outlives this Shell.
   DCHECK(chromeos::DBusThreadManager::IsInitialized());
-#endif
 
   // Needs to happen right before |instance_| is reset.
   wm_shell_.reset();
 
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   wm_shell_->Initialize(init_params.blocking_pool);
 
   immersive_handler_factory_ = base::MakeUnique<ImmersiveHandlerFactoryAsh>();
 
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-  NOTREACHED() << "linux desktop does not support ash.";
-#endif
-
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_.reset(new WindowPositioner(wm_shell_.get()));
 
   native_cursor_manager_ = new AshNativeCursorManager;
-#if defined(OS_CHROMEOS)
   cursor_manager_.reset(
       new CursorManager(base::WrapUnique(native_cursor_manager_)));
-#else
-  cursor_manager_.reset(
-      new ::wm::CursorManager(base::WrapUnique(native_cursor_manager_)));
-#endif
 
   wm_shell_->delegate()->PreInit();
   bool display_initialized = display_manager_->InitFromCommandLine();
 
   display_configuration_controller_.reset(new DisplayConfigurationController(
       display_manager_.get(), window_tree_host_manager_.get()));
 
-#if defined(OS_CHROMEOS)
-
 #if defined(USE_OZONE)
   display_configurator_->Init(
       ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(),
       !gpu_support_->IsPanelFittingDisabled());
 #elif defined(USE_X11)
   display_configurator_->Init(
       base::MakeUnique<display::NativeDisplayDelegateX11>(),
       !gpu_support_->IsPanelFittingDisabled());
 #endif
 
@@ skipping 21 matching lines @@
     display_configurator_->set_mirroring_controller(display_manager_.get());
     display_configurator_->ForceInitialConfigure(
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             chromeos::switches::kFirstExecAfterBoot)
             ? kChromeOsBootColor
             : 0);
     display_initialized = true;
   }
   display_color_manager_.reset(new DisplayColorManager(
       display_configurator_.get(), init_params.blocking_pool));
-#endif  // defined(OS_CHROMEOS)
 
   if (!display_initialized)
     display_manager_->InitDefaultDisplay();
 
   display_manager_->RefreshFontParams();
 
   aura::Env::GetInstance()->set_context_factory(init_params.context_factory);
   aura::Env::GetInstance()->set_context_factory_private(
       init_params.context_factory_private);
 
@@ skipping 13 matching lines @@
   activation_client_ = focus_controller;
 
   screen_position_controller_.reset(new ScreenPositionController);
 
   window_tree_host_manager_->Start();
   AshWindowTreeHostInitParams ash_init_params;
   window_tree_host_manager_->CreatePrimaryHost(ash_init_params);
   aura::Window* root_window = window_tree_host_manager_->GetPrimaryRootWindow();
   wm_shell_->set_root_window_for_new_windows(WmWindowAura::Get(root_window));
 
-#if defined(OS_CHROMEOS)
   resolution_notification_controller_.reset(
       new ResolutionNotificationController);
-#endif
 
   if (cursor_manager_)
     cursor_manager_->SetDisplay(
         display::Screen::GetScreen()->GetPrimaryDisplay());
 
   accelerator_controller_delegate_.reset(new AcceleratorControllerDelegateAura);
   wm_shell_->SetAcceleratorController(base::MakeUnique<AcceleratorController>(
       accelerator_controller_delegate_.get(), nullptr));
   wm_shell_->CreateMaximizeModeController();
 
   AddPreTargetHandler(window_tree_host_manager_->input_method_event_handler());
 
-#if defined(OS_CHROMEOS)
   magnifier_key_scroll_handler_ = MagnifierKeyScroller::CreateHandler();
   AddPreTargetHandler(magnifier_key_scroll_handler_.get());
   speech_feedback_handler_ = SpokenFeedbackToggler::CreateHandler();
   AddPreTargetHandler(speech_feedback_handler_.get());
-#endif
 
   // The order in which event filters are added is significant.
 
   // ui::UserActivityDetector passes events to observers, so let them get
   // rewritten first.
   user_activity_detector_.reset(new ui::UserActivityDetector);
 
   overlay_filter_.reset(new OverlayEventFilter);
   AddPreTargetHandler(overlay_filter_.get());
   wm_shell_->AddShellObserver(overlay_filter_.get());
 
   accelerator_filter_.reset(new ::wm::AcceleratorFilter(
       std::unique_ptr<::wm::AcceleratorDelegate>(new AcceleratorDelegate),
       wm_shell_->accelerator_controller()->accelerator_history()));
   AddPreTargetHandler(accelerator_filter_.get());
 
   event_transformation_handler_.reset(new EventTransformationHandler);
   AddPreTargetHandler(event_transformation_handler_.get());
 
   toplevel_window_event_handler_.reset(
       new ToplevelWindowEventHandler(wm_shell_.get()));
 
   system_gesture_filter_.reset(new SystemGestureEventFilter);
   AddPreTargetHandler(system_gesture_filter_.get());
 
-#if defined(OS_CHROMEOS)
   sticky_keys_controller_.reset(new StickyKeysController);
-#endif
   screen_pinning_controller_.reset(
       new ScreenPinningController(window_tree_host_manager_.get()));
 
   lock_state_controller_ =
       base::MakeUnique<LockStateController>(wm_shell_->shutdown_controller());
   power_button_controller_.reset(
       new PowerButtonController(lock_state_controller_.get()));
-#if defined(OS_CHROMEOS)
   // Pass the initial display state to PowerButtonController.
   power_button_controller_->OnDisplayModeChanged(
       display_configurator_->cached_displays());
-#endif
+
   wm_shell_->AddShellObserver(lock_state_controller_.get());
 
   drag_drop_controller_.reset(new DragDropController);
   // |screenshot_controller_| needs to be created (and prepended as a
   // pre-target handler) at this point, because |mouse_cursor_filter_| needs to
   // process mouse events prior to screenshot session.
   // See http://crbug.com/459214
   screenshot_controller_.reset(new ScreenshotController());
   mouse_cursor_filter_.reset(new MouseCursorEventFilter());
   PrependPreTargetHandler(mouse_cursor_filter_.get());
 
   // Create Controllers that may need root window.
   // TODO(oshima): Move as many controllers before creating
   // RootWindowController as possible.
   visibility_controller_.reset(new AshVisibilityController);
 
-#if defined(OS_CHROMEOS)
   laser_pointer_controller_.reset(new LaserPointerController());
   partial_magnification_controller_.reset(new PartialMagnificationController());
-#endif
 
   magnification_controller_.reset(MagnificationController::CreateInstance());
   wm_shell_->CreateMruWindowTracker();
 
   autoclick_controller_.reset(AutoclickController::CreateInstance());
 
   high_contrast_controller_.reset(new HighContrastController);
   video_detector_.reset(new VideoDetector);
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
       std::unique_ptr<views::corewm::Tooltip>(new views::corewm::TooltipAura)));
   AddPreTargetHandler(tooltip_controller_.get());
 
   modality_filter_.reset(new SystemModalContainerEventFilter(this));
   AddPreTargetHandler(modality_filter_.get());
 
   event_client_.reset(new EventClientImpl);
 
   session_state_delegate_.reset(
       wm_shell_->delegate()->CreateSessionStateDelegate());
   wm_shell_->CreatePointerWatcherAdapter();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
   shadow_controller_.reset(new ::wm::ShadowController(activation_client_));
 
   wm_shell_->SetSystemTrayDelegate(
       base::WrapUnique(wm_shell_->delegate()->CreateSystemTrayDelegate()));
 
-#if defined(OS_CHROMEOS)
   // Create TouchTransformerController before
   // WindowTreeHostManager::InitDisplays()
   // since TouchTransformerController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
   touch_transformer_controller_.reset(new TouchTransformerController());
-#endif  // defined(OS_CHROMEOS)
 
   wm_shell_->SetKeyboardUI(KeyboardUI::Create());
 
   window_tree_host_manager_->InitHosts();
 
-#if defined(OS_CHROMEOS)
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
   virtual_keyboard_controller_.reset(new VirtualKeyboardController);
-#endif  // defined(OS_CHROMEOS)
 
-#if defined(OS_CHROMEOS)
   audio_a11y_controller_.reset(new chromeos::AudioA11yController);
-#endif  // defined(OS_CHROMEOS)
 
   // Initialize the wallpaper after the RootWindowController has been created,
   // otherwise the widget will not paint when restoring after a browser crash.
   // Also, initialize after display initialization to ensure correct sizing.
   wm_shell_->wallpaper_delegate()->InitializeWallpaper();
 
   if (cursor_manager_) {
     if (initially_hide_cursor_)
       cursor_manager_->HideCursor();
     cursor_manager_->SetCursor(ui::kCursorPointer);
   }
 
-#if defined(OS_CHROMEOS)
   power_event_observer_.reset(new PowerEventObserver());
   user_activity_notifier_.reset(
       new ui::UserActivityPowerManagerNotifier(user_activity_detector_.get()));
   video_activity_notifier_.reset(
       new VideoActivityNotifier(video_detector_.get()));
   bluetooth_notification_controller_.reset(new BluetoothNotificationController);
   screen_orientation_controller_.reset(new ScreenOrientationController());
   screen_layout_observer_.reset(new ScreenLayoutObserver());
-#endif
+
   // The compositor thread and main message loop have to be running in
   // order to create mirror window. Run it after the main message loop
   // is started.
   display_manager_->CreateMirrorWindowAsyncIfAny();
 
   for (auto& observer : *wm_shell_->shell_observers())
     observer.OnShellInitialized();
 
   user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
   if (keyboard::IsKeyboardEnabled()) {
     if (keyboard::KeyboardController::GetInstance()) {
       RootWindowControllerList controllers = GetAllRootWindowControllers();
       for (RootWindowControllerList::iterator iter = controllers.begin();
            iter != controllers.end(); ++iter) {
         (*iter)->DeactivateKeyboard(
             keyboard::KeyboardController::GetInstance());
       }
     }
-#if defined(OS_CHROMEOS)
     keyboard::KeyboardController::ResetInstance(
         new keyboard::KeyboardController(
             wm_shell_->delegate()->CreateKeyboardUI(),
             virtual_keyboard_controller_.get()));
-#else
-    keyboard::KeyboardController::ResetInstance(
-        new keyboard::KeyboardController(
-            wm_shell_->delegate()->CreateKeyboardUI(), nullptr));
-
-#endif
   }
 }
 
 void Shell::InitRootWindow(aura::Window* root_window) {
   DCHECK(activation_client_);
   DCHECK(visibility_controller_.get());
   DCHECK(drag_drop_controller_.get());
 
   aura::client::SetFocusClient(root_window, focus_client_.get());
   aura::client::SetActivationClient(root_window, activation_client_);
@@ skipping 37 matching lines @@
 std::unique_ptr<ui::EventTargetIterator> Shell::GetChildIterator() const {
   return std::unique_ptr<ui::EventTargetIterator>();
 }
 
 ui::EventTargeter* Shell::GetEventTargeter() {
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace ash