Renames WmShell to ShellPort

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.h"
 #include "ash/accelerators/accelerator_delegate.h"
 #include "ash/accelerators/ash_focus_manager_factory.h"
 #include "ash/accelerators/magnifier_key_scroller.h"
 #include "ash/accelerators/spoken_feedback_toggler.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/app_list/app_list_delegate_impl.h"
 #include "ash/ash_constants.h"
-#include "ash/aura/wm_shell_aura.h"
+#include "ash/aura/shell_port_classic.h"
 #include "ash/autoclick/autoclick_controller.h"
 #include "ash/cast_config_controller.h"
 #include "ash/devtools/ash_devtools_css_agent.h"
 #include "ash/devtools/ash_devtools_dom_agent.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"
@@ skipping 25 matching lines @@
 #include "ash/session/session_controller.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf_controller.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_window_watcher.h"
 #include "ash/shelf/wm_shelf.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_init_params.h"
 #include "ash/shell_observer.h"
+#include "ash/shell_port.h"
 #include "ash/shutdown_controller.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
 #include "ash/system/bluetooth/bluetooth_notification_controller.h"
 #include "ash/system/bluetooth/tray_bluetooth_helper.h"
 #include "ash/system/brightness/brightness_controller_chromeos.h"
 #include "ash/system/brightness_control_delegate.h"
 #include "ash/system/keyboard_brightness_control_delegate.h"
 #include "ash/system/keyboard_brightness_controller.h"
 #include "ash/system/locale/locale_notification_controller.h"
 #include "ash/system/network/sms_observer.h"
@@ skipping 34 matching lines @@
 #include "ash/wm/system_modal_container_event_filter.h"
 #include "ash/wm/system_modal_container_layout_manager.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_cycle_controller.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
-#include "ash/wm_shell.h"
 #include "ash/wm_window.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/threading/sequenced_worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "chromeos/audio/audio_a11y_controller.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 85 matching lines @@
 aura::WindowManagerClient* Shell::window_manager_client_ = nullptr;
 // static
 bool Shell::initially_hide_cursor_ = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 // static
 Shell* Shell::CreateInstance(const ShellInitParams& init_params) {
   CHECK(!instance_);
-  WmShell* wm_shell = init_params.wm_shell;
-  if (!wm_shell)
-    wm_shell = new WmShellAura();
+  ShellPort* shell_port = init_params.shell_port;
+  if (!shell_port)
+    shell_port = new ShellPortClassic();
   instance_ = new Shell(base::WrapUnique<ShellDelegate>(init_params.delegate),
-                        base::WrapUnique<WmShell>(wm_shell));
+                        base::WrapUnique<ShellPort>(shell_port));
   instance_->Init(init_params);
   return instance_;
 }
 
 // static
 Shell* Shell::Get() {
   CHECK(instance_);
   return instance_;
 }
 
@@ skipping 10 matching lines @@
 // static
 RootWindowController* Shell::GetPrimaryRootWindowController() {
   CHECK(HasInstance());
   return GetRootWindowController(GetPrimaryRootWindow());
 }
 
 // static
 Shell::RootWindowControllerList Shell::GetAllRootWindowControllers() {
   CHECK(HasInstance());
   RootWindowControllerList root_window_controllers;
-  for (WmWindow* root_window : instance_->wm_shell_->GetAllRootWindows())
+  for (WmWindow* root_window : instance_->shell_port_->GetAllRootWindows())
     root_window_controllers.push_back(root_window->GetRootWindowController());
   return root_window_controllers;
 }
 
 // static
 RootWindowController* Shell::GetRootWindowControllerWithDisplayId(
     int64_t display_id) {
   CHECK(HasInstance());
   WmWindow* root_window =
-      instance_->wm_shell_->GetRootWindowForDisplayId(display_id);
+      instance_->shell_port_->GetRootWindowForDisplayId(display_id);
   return root_window ? root_window->GetRootWindowController() : nullptr;
 }
 
 // static
 aura::Window* Shell::GetPrimaryRootWindow() {
   CHECK(HasInstance());
-  return instance_->wm_shell_->GetPrimaryRootWindow()->aura_window();
+  return instance_->shell_port_->GetPrimaryRootWindow()->aura_window();
 }
 
 // static
 aura::Window* Shell::GetRootWindowForNewWindows() {
   CHECK(Shell::HasInstance());
   return WmWindow::GetAuraWindow(Shell::GetWmRootWindowForNewWindows());
 }
 
 // static
 WmWindow* Shell::GetWmRootWindowForNewWindows() {
   CHECK(Shell::HasInstance());
   Shell* shell = Shell::Get();
   if (shell->scoped_root_window_for_new_windows_)
     return shell->scoped_root_window_for_new_windows_;
   return shell->root_window_for_new_windows_;
 }
 
 // static
 aura::Window::Windows Shell::GetAllRootWindows() {
   CHECK(HasInstance());
   aura::Window::Windows windows;
-  for (WmWindow* window : instance_->wm_shell_->GetAllRootWindows())
+  for (WmWindow* window : instance_->shell_port_->GetAllRootWindows())
     windows.push_back(window->aura_window());
   return windows;
 }
 
 // static
 aura::Window* Shell::GetContainer(aura::Window* root_window, int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
 const aura::Window* Shell::GetContainer(const aura::Window* root_window,
                                         int container_id) {
   return root_window->GetChildById(container_id);
 }
 
 // static
 Config Shell::GetAshConfig() {
-  return Get()->wm_shell_->GetAshConfig();
+  return Get()->shell_port_->GetAshConfig();
 }
 
 views::NonClientFrameView* Shell::CreateDefaultNonClientFrameView(
     views::Widget* widget) {
   // Use translucent-style window frames for dialogs.
   return new CustomFrameViewAsh(widget);
 }
 
 void Shell::SetDisplayWorkAreaInsets(Window* contains,
                                      const gfx::Insets& insets) {
-  wm_shell_->SetDisplayWorkAreaInsets(WmWindow::Get(contains), insets);
+  shell_port_->SetDisplayWorkAreaInsets(WmWindow::Get(contains), insets);
 }
 
 void Shell::OnAppTerminating() {
   for (auto& observer : shell_observers_)
     observer.OnAppTerminating();
 }
 
 void Shell::OnLockStateChanged(bool locked) {
   for (auto& observer : shell_observers_)
     observer.OnLockStateChanged(locked);
@@ skipping 18 matching lines @@
     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.
+  // TODO(jamescook): Move keyboard create and hide into ShellPort.
   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);
 }
 
 bool Shell::ShouldSaveDisplaySettings() {
-  DCHECK(!wm_shell_->IsRunningInMash());
+  DCHECK(!shell_port_->IsRunningInMash());
   return !(
       screen_orientation_controller_->ignore_display_configuration_updates() ||
       resolution_notification_controller_->DoesNotificationTimeout());
 }
 
 ShelfModel* Shell::shelf_model() {
   return shelf_controller_->model();
 }
 
 aura::client::ActivationClient* Shell::activation_client() {
   return focus_controller_.get();
 }
 
 void Shell::UpdateShelfVisibility() {
-  for (WmWindow* root : wm_shell_->GetAllRootWindows())
+  for (WmWindow* root : shell_port_->GetAllRootWindows())
     root->GetRootWindowController()->GetShelf()->UpdateVisibilityState();
 }
 
 WebNotificationTray* Shell::GetWebNotificationTray() {
   return GetPrimaryRootWindowController()
       ->GetStatusAreaWidget()
       ->web_notification_tray();
 }
 
 bool Shell::HasPrimaryStatusArea() {
@@ skipping 16 matching lines @@
 FirstRunHelper* Shell::CreateFirstRunHelper() {
   return new FirstRunHelperImpl;
 }
 
 void Shell::CreateShelfView() {
   // Must occur after SessionController creation and user login.
   DCHECK(session_controller());
   DCHECK_GT(session_controller()->NumberOfLoggedInUsers(), 0);
   CreateShelfDelegate();
 
-  for (WmWindow* root_window : wm_shell_->GetAllRootWindows())
+  for (WmWindow* root_window : shell_port_->GetAllRootWindows())
     root_window->GetRootWindowController()->CreateShelfView();
 }
 
 void Shell::SetLargeCursorSizeInDip(int large_cursor_size_in_dip) {
   window_tree_host_manager_->cursor_window_controller()
       ->SetLargeCursorSizeInDip(large_cursor_size_in_dip);
 }
 
 void Shell::SetCursorCompositingEnabled(bool enabled) {
   if (GetAshConfig() == Config::CLASSIC) {
@@ skipping 36 matching lines @@
 
 bool Shell::IsAppListVisible() const {
   return app_list_->IsVisible();
 }
 
 bool Shell::GetAppListTargetVisibility() const {
   return app_list_->GetTargetVisibility();
 }
 
 void Shell::UpdateAfterLoginStatusChange(LoginStatus status) {
-  for (WmWindow* root_window : wm_shell_->GetAllRootWindows()) {
+  for (WmWindow* root_window : shell_port_->GetAllRootWindows()) {
     root_window->GetRootWindowController()->UpdateAfterLoginStatusChange(
         status);
   }
 }
 
 void Shell::NotifyMaximizeModeStarted() {
   for (auto& observer : shell_observers_)
     observer.OnMaximizeModeStarted();
 }
 
@@ skipping 46 matching lines @@
 
 void Shell::NotifyShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   for (auto& observer : shell_observers_)
     observer.OnShelfAutoHideBehaviorChanged(root_window);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(std::unique_ptr<ShellDelegate> shell_delegate,
-             std::unique_ptr<WmShell> wm_shell)
-    : wm_shell_(std::move(wm_shell)),
+             std::unique_ptr<ShellPort> shell_port)
+    : shell_port_(std::move(shell_port)),
       brightness_control_delegate_(
           base::MakeUnique<system::BrightnessControllerChromeos>()),
       cast_config_(base::MakeUnique<CastConfigController>()),
       focus_cycler_(base::MakeUnique<FocusCycler>()),
       immersive_context_(base::MakeUnique<ImmersiveContextAsh>()),
       keyboard_brightness_control_delegate_(
           base::MakeUnique<KeyboardBrightnessController>()),
       locale_notification_controller_(
           base::MakeUnique<LocaleNotificationController>()),
       media_controller_(base::MakeUnique<MediaController>()),
       new_window_controller_(base::MakeUnique<NewWindowController>()),
       session_controller_(base::MakeUnique<SessionController>()),
       shelf_controller_(base::MakeUnique<ShelfController>()),
       shell_delegate_(std::move(shell_delegate)),
       shutdown_controller_(base::MakeUnique<ShutdownController>()),
       system_tray_controller_(base::MakeUnique<SystemTrayController>()),
       system_tray_notifier_(base::MakeUnique<SystemTrayNotifier>()),
       vpn_list_(base::MakeUnique<VpnList>()),
       window_cycle_controller_(base::MakeUnique<WindowCycleController>()),
       window_selector_controller_(base::MakeUnique<WindowSelectorController>()),
       app_list_(base::MakeUnique<app_list::AppList>()),
       link_handler_model_factory_(nullptr),
       tray_bluetooth_helper_(base::MakeUnique<TrayBluetoothHelper>()),
       display_configurator_(new display::DisplayConfigurator()),
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
       is_touch_hud_projection_enabled_(false) {
   // TODO(sky): better refactor cash/mash dependencies. Perhaps put all cash
-  // state on WmShellAura. http://crbug.com/671246.
+  // state on ShellPortClassic. http://crbug.com/671246.
 
-  if (!wm_shell_->IsRunningInMash()) {
+  if (!shell_port_->IsRunningInMash()) {
     gpu_support_.reset(shell_delegate_->CreateGPUSupport());
     display_manager_.reset(ScreenAsh::CreateDisplayManager());
     window_tree_host_manager_.reset(new WindowTreeHostManager);
     user_metrics_recorder_.reset(new UserMetricsRecorder);
   }
 
   PowerStatus::Initialize();
 
   session_controller_->AddSessionStateObserver(this);
 }
 
 Shell::~Shell() {
   TRACE_EVENT0("shutdown", "ash::Shell::Destructor");
 
-  const Config config = wm_shell_->GetAshConfig();
+  const Config config = shell_port_->GetAshConfig();
 
   if (config != Config::MASH)
     user_metrics_recorder_->OnShellShuttingDown();
 
   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);
@@ skipping 39 matching lines @@
   maximize_mode_controller_.reset();
 
   // Destroy the keyboard before closing the shelf, since it will invoke a shelf
   // layout.
   DeactivateKeyboard();
 
   toast_manager_.reset();
 
   // 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())
+  for (WmWindow* root : shell_port_->GetAllRootWindows())
     root->GetRootWindowController()->GetShelf()->ShutdownShelfWidget();
   tray_bluetooth_helper_.reset();
   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.
 
@@ skipping 65 matching lines @@
   // ShelfItemDelegate subclasses it owns have complex cleanup to run (e.g. ARC
   // shelf items in Chrome) so explicitly shutdown early.
   shelf_model()->DestroyItemDelegates();
 
   // Must be destroyed before FocusController.
   shelf_delegate_.reset();
 
   // Removes itself as an observer of |pref_service_|.
   shelf_controller_.reset();
 
-  wm_shell_->Shutdown();
+  shell_port_->Shutdown();
 
   // Depends on |focus_controller_|, so must be destroyed before.
   window_tree_host_manager_.reset();
   focus_controller_->RemoveObserver(this);
   focus_controller_.reset();
   screen_position_controller_.reset();
 
   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());
     RemoveShellObserver(projecting_observer_.get());
   }
   display_change_observer_.reset();
   shutdown_observer_.reset();
 
   PowerStatus::Shutdown();
 
   // Ensure that DBusThreadManager outlives this Shell.
   DCHECK(chromeos::DBusThreadManager::IsInitialized());
 
   // Needs to happen right before |instance_| is reset.
-  wm_shell_.reset();
+  shell_port_.reset();
   session_controller_->RemoveSessionStateObserver(this);
   wallpaper_delegate_.reset();
   pref_service_ = nullptr;
   shell_delegate_.reset();
 
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
-  const bool is_mash = wm_shell_->IsRunningInMash();
-  const Config config = wm_shell_->GetAshConfig();
+  const bool is_mash = shell_port_->IsRunningInMash();
+  const Config config = shell_port_->GetAshConfig();
 
   blocking_pool_ = init_params.blocking_pool;
 
   wallpaper_delegate_ = shell_delegate_->CreateWallpaperDelegate();
 
   // Can be null in tests.
-  if (wm_shell_->IsRunningInMash() && shell_delegate_->GetShellConnector()) {
+  if (shell_port_->IsRunningInMash() && shell_delegate_->GetShellConnector()) {
     prefs::ConnectToPrefService(
         shell_delegate_->GetShellConnector(),
         make_scoped_refptr(new PrefRegistrySimple()),
         std::vector<PrefValueStore::PrefStoreType>(),
         base::Bind(&Shell::OnPrefServiceInitialized, base::Unretained(this)),
         prefs::mojom::kForwarderServiceName);
   }
 
-  // Some delegates access WmShell during their construction. Create them here
-  // instead of the WmShell constructor.
+  // Some delegates access ShellPort during their construction. Create them here
+  // instead of the ShellPort constructor.
   accessibility_delegate_.reset(shell_delegate_->CreateAccessibilityDelegate());
   palette_delegate_ = shell_delegate_->CreatePaletteDelegate();
   toast_manager_ = base::MakeUnique<ToastManager>();
 
   // Install the custom factory early on so that views::FocusManagers for Tray,
   // Shelf, and WallPaper could be created by the factory.
   views::FocusManagerFactory::Install(new AshFocusManagerFactory);
 
   wallpaper_controller_ = base::MakeUnique<WallpaperController>(blocking_pool_);
 
   // Start devtools server
   devtools_server_ = ui::devtools::UiDevToolsServer::Create(nullptr);
   if (devtools_server_) {
     auto dom_backend = base::MakeUnique<devtools::AshDevToolsDOMAgent>();
     auto css_backend =
         base::MakeUnique<devtools::AshDevToolsCSSAgent>(dom_backend.get());
     auto devtools_client = base::MakeUnique<ui::devtools::UiDevToolsClient>(
         "Ash", devtools_server_.get());
     devtools_client->AddAgent(std::move(dom_backend));
     devtools_client->AddAgent(std::move(css_backend));
     devtools_server_->AttachClient(std::move(devtools_client));
   }
 
   if (is_mash)
     app_list_delegate_impl_ = base::MakeUnique<AppListDelegateImpl>();
 
-  // TODO(sky): move creation to WmShell.
+  // TODO(sky): move creation to ShellPort.
   if (!is_mash)
     immersive_handler_factory_ = base::MakeUnique<ImmersiveHandlerFactoryAsh>();
 
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_ = base::MakeUnique<WindowPositioner>();
 
   if (config == Config::CLASSIC) {
     // TODO: needs to work in mus. http://crbug.com/705592.
     native_cursor_manager_ = new AshNativeCursorManager;
@@ skipping 73 matching lines @@
   env_filter_.reset(new ::wm::CompoundEventFilter);
   AddPreTargetHandler(env_filter_.get());
 
   // FocusController takes ownership of AshFocusRules.
   focus_controller_ =
       base::MakeUnique<::wm::FocusController>(new wm::AshFocusRules());
   focus_controller_->AddObserver(this);
 
   screen_position_controller_.reset(new ScreenPositionController);
 
-  wm_shell_->CreatePrimaryHost();
+  shell_port_->CreatePrimaryHost();
   root_window_for_new_windows_ = WmWindow::Get(GetPrimaryRootWindow());
 
   if (!is_mash) {
     resolution_notification_controller_.reset(
         new ResolutionNotificationController);
   }
 
   if (cursor_manager_) {
     cursor_manager_->SetDisplay(
         display::Screen::GetScreen()->GetPrimaryDisplay());
   }
 
-  accelerator_controller_ = wm_shell_->CreateAcceleratorController();
+  accelerator_controller_ = shell_port_->CreateAcceleratorController();
   maximize_mode_controller_ = base::MakeUnique<MaximizeModeController>();
 
   if (config == Config::CLASSIC) {
     // Not applicable to mus/mash as events are already routed to InputMethod
     // first.
     AddPreTargetHandler(
         window_tree_host_manager_->input_method_event_handler());
   }
 
   magnifier_key_scroll_handler_ = MagnifierKeyScroller::CreateHandler();
@@ skipping 12 matching lines @@
   AddShellObserver(overlay_filter_.get());
 
   accelerator_filter_.reset(new ::wm::AcceleratorFilter(
       std::unique_ptr<::wm::AcceleratorDelegate>(new AcceleratorDelegate),
       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()));
+  toplevel_window_event_handler_ =
+      base::MakeUnique<ToplevelWindowEventHandler>();
 
   if (!is_mash) {
     system_gesture_filter_.reset(new SystemGestureEventFilter);
     AddPreTargetHandler(system_gesture_filter_.get());
   }
 
   sticky_keys_controller_.reset(new StickyKeysController);
   screen_pinning_controller_ = base::MakeUnique<ScreenPinningController>();
 
   lock_state_controller_ =
@@ skipping 49 matching lines @@
   AddPreTargetHandler(tooltip_controller_.get());
 
   modality_filter_.reset(new SystemModalContainerEventFilter(this));
   AddPreTargetHandler(modality_filter_.get());
 
   event_client_.reset(new EventClientImpl);
 
   session_state_delegate_.reset(shell_delegate_->CreateSessionStateDelegate());
   // Must occur after Shell has installed its early pre-target handlers (for
   // example, WindowModalityController).
-  wm_shell_->CreatePointerWatcherAdapter();
+  shell_port_->CreatePointerWatcherAdapter();
 
   resize_shadow_controller_.reset(new ResizeShadowController());
   shadow_controller_.reset(new ::wm::ShadowController(focus_controller_.get()));
 
   SetSystemTrayDelegate(
       base::WrapUnique(shell_delegate_->CreateSystemTrayDelegate()));
 
   // May trigger initialization of the Bluetooth adapter.
   tray_bluetooth_helper_->Initialize();
 
   // Create AshTouchTransformController before
   // WindowTreeHostManager::InitDisplays()
   // since AshTouchTransformController listens on
   // WindowTreeHostManager::Observer::OnDisplaysInitialized().
   if (!is_mash) {
     touch_transformer_controller_.reset(new AshTouchTransformController(
         display_configurator_.get(), display_manager_.get()));
   }
 
-  keyboard_ui_ = wm_shell_->CreateKeyboardUI();
+  keyboard_ui_ = shell_port_->CreateKeyboardUI();
 
-  wm_shell_->InitHosts(init_params);
+  shell_port_->InitHosts(init_params);
 
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
   if (!is_mash)
     virtual_keyboard_controller_.reset(new VirtualKeyboardController);
 
   audio_a11y_controller_.reset(new chromeos::AudioA11yController);
 
   // Initialize the wallpaper after the RootWindowController has been created,
   // otherwise the widget will not paint when restoring after a browser crash.
@@ skipping 67 matching lines @@
                                     toplevel_window_event_handler_.get());
   root_window->AddPreTargetHandler(toplevel_window_event_handler_.get());
   root_window->AddPostTargetHandler(toplevel_window_event_handler_.get());
 }
 
 void Shell::SetSystemTrayDelegate(
     std::unique_ptr<SystemTrayDelegate> delegate) {
   DCHECK(delegate);
   system_tray_delegate_ = std::move(delegate);
   system_tray_delegate_->Initialize();
-  // Accesses WmShell in its constructor.
+  // Accesses ShellPort in its constructor.
   logout_confirmation_controller_.reset(new LogoutConfirmationController(
       base::Bind(&SystemTrayController::SignOut,
                  base::Unretained(system_tray_controller_.get()))));
 }
 
 void Shell::DeleteSystemTrayDelegate() {
   DCHECK(system_tray_delegate_);
-  // Accesses WmShell in its destructor.
+  // Accesses ShellPort in its destructor.
   logout_confirmation_controller_.reset();
   system_tray_delegate_.reset();
 }
 
 void Shell::CloseAllRootWindowChildWindows() {
-  for (WmWindow* wm_root_window : wm_shell_->GetAllRootWindows()) {
+  for (WmWindow* wm_root_window : shell_port_->GetAllRootWindows()) {
     aura::Window* root_window = wm_root_window->aura_window();
     RootWindowController* controller = GetRootWindowController(root_window);
     if (controller) {
       controller->CloseChildWindows();
     } else {
       while (!root_window->children().empty()) {
         aura::Window* child = root_window->children()[0];
         delete child;
       }
     }
@@ skipping 50 matching lines @@
   if (gained_active_wm)
     root_window_for_new_windows_ = gained_active_wm->GetRootWindow();
 }
 
 void Shell::SessionStateChanged(session_manager::SessionState state) {
   // Create the shelf when a session becomes active. It's safe to do this
   // multiple times (e.g. initial login vs. multiprofile add session).
   if (state == session_manager::SessionState::ACTIVE) {
     CreateShelfView();
 
-    if (!wm_shell_->IsRunningInMash()) {
+    if (!shell_port_->IsRunningInMash()) {
       // Recreate the keyboard after initial login and after multiprofile login.
       CreateKeyboard();
     }
   }
 }
 
 void Shell::LoginStatusChanged(LoginStatus login_status) {
   UpdateAfterLoginStatusChange(login_status);
 
   // TODO(xiyuan): Update OnLoginStateChanged -> OnLoginStatusChanged.
   for (auto& observer : shell_observers_)
     observer.OnLoginStateChanged(login_status);
 }
 
 void Shell::OnPrefServiceInitialized(
     std::unique_ptr<::PrefService> pref_service) {
   if (!instance_)
     return;
   DCHECK(pref_service);
   pref_service_ = std::move(pref_service);
 }
 
 }  // namespace ash