Renames WmShell to ShellPort

ash/mus/window_manager.cc

 // Copyright 2015 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/mus/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
-#include "ash/mus/bridge/wm_shell_mus.h"
+#include "ash/mus/bridge/shell_port_mash.h"
 #include "ash/mus/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/screen_mus.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/top_level_window_factory.h"
 #include "ash/mus/window_properties.h"
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shelf_types.h"
 #include "ash/public/cpp/shell_window_ids.h"
@@ skipping 188 matching lines @@
   CreateAndRegisterRootWindowController(
       std::move(window_tree_host), screen_->GetAllDisplays()[0],
       RootWindowController::RootWindowType::PRIMARY);
 }
 
 void WindowManager::CreateShell(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   DCHECK(!created_shell_);
   created_shell_ = true;
   ShellInitParams init_params;
-  WmShellMus* wm_shell = new WmShellMus(
-      WmWindow::Get(window_tree_host->window()),
-      this, pointer_watcher_event_router_.get(),
-      create_session_state_delegate_stub_for_test_);
+  ShellPortMash* shell_port =
+      new ShellPortMash(WmWindow::Get(window_tree_host->window()), this,
+                        pointer_watcher_event_router_.get(),
+                        create_session_state_delegate_stub_for_test_);
   // Shell::CreateInstance() takes ownership of ShellDelegate.
   init_params.delegate = shell_delegate_ ? shell_delegate_.release()
                                          : new ShellDelegateMus(connector_);
   init_params.primary_window_tree_host = window_tree_host.release();
-  init_params.wm_shell = wm_shell;
+  init_params.shell_port = shell_port;
   init_params.blocking_pool = blocking_pool_.get();
   Shell::CreateInstance(init_params);
 }
 
 void WindowManager::CreateAndRegisterRootWindowController(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host,
     const display::Display& display,
     RootWindowController::RootWindowType root_window_type) {
   RootWindowSettings* root_window_settings =
       InitRootWindowSettings(window_tree_host->window());
@@ skipping 43 matching lines @@
 
   Shell::DeleteInstance();
 
   pointer_watcher_event_router_.reset();
 
   window_tree_client_.reset();
   window_manager_client_ = nullptr;
 }
 
 RootWindowController* WindowManager::GetPrimaryRootWindowController() {
-  return RootWindowController::ForWindow(WmShell::Get()
+  return RootWindowController::ForWindow(ShellPort::Get()
                                              ->GetPrimaryRootWindowController()
                                              ->GetWindow()
                                              ->aura_window());
 }
 
 void WindowManager::OnEmbed(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   // WindowManager should never see this, instead OnWmNewDisplay() is called.
   NOTREACHED();
 }
@@ skipping 151 matching lines @@
       screen_->display_list().displays().size() == 1
           ? RootWindowController::RootWindowType::PRIMARY
           : RootWindowController::RootWindowType::SECONDARY;
   // The ash startup sequence creates the Shell, which creates
   // WindowTreeHostManager, which creates the WindowTreeHosts and
   // RootWindowControllers. For mash we are supplied the WindowTreeHost when
   // a display is added (and WindowTreeHostManager is not used in mash). Mash
   // waits for the first WindowTreeHost, then creates the shell. As there are
   // order dependencies we have to create the RootWindowController at a similar
   // time as cash, to do that we inject the WindowTreeHost into ShellInitParams.
-  // Shell calls to WmShell::InitHosts(), which calls back to
+  // Shell calls to ShellPort::InitHosts(), which calls back to
   // CreatePrimaryRootWindowController().
   if (!created_shell_) {
     CreateShell(std::move(window_tree_host));
     return;
   }
   CreateAndRegisterRootWindowController(std::move(window_tree_host), display,
                                         root_window_type);
 
   for (auto& observer : *screen_->display_list().observers())
     observer.OnDisplayAdded(display);
@@ skipping 16 matching lines @@
   // and finally DisplayObservers.
   display::DisplayList& display_list = screen_->display_list();
   std::unique_ptr<display::DisplayListObserverLock> display_lock =
       display_list.SuspendObserverUpdates();
   const bool is_primary = display_list.FindDisplayById(display.id()) ==
                           display_list.GetPrimaryDisplayIterator();
   uint32_t display_changed_values = display_list.UpdateDisplay(
       display, is_primary ? display::DisplayList::Type::PRIMARY
                           : display::DisplayList::Type::NOT_PRIMARY);
   RootWindowController* root_window_controller =
-      WmShellMus::Get()->GetRootWindowControllerWithDisplayId(display.id());
+      ShellPortMash::Get()->GetRootWindowControllerWithDisplayId(display.id());
   DCHECK(root_window_controller);
   root_window_controller->GetRootWindow()->GetHost()->SetBoundsInPixels(
       display.bounds());
   display_lock.reset();
   for (display::DisplayObserver& observer : *(display_list.observers()))
     observer.OnDisplayMetricsChanged(display, display_changed_values);
 }
 
 void WindowManager::OnWmPerformMoveLoop(
     aura::Window* window,
@@ skipping 47 matching lines @@
 bool WindowManager::IsWindowActive(aura::Window* window) {
   return Shell::Get()->activation_client()->GetActiveWindow() == window;
 }
 
 void WindowManager::OnWmDeactivateWindow(aura::Window* window) {
   Shell::Get()->activation_client()->DeactivateWindow(window);
 }
 
 }  // namespace mus
 }  // namespace ash