Removes ShellPort::IsRunningInMash()

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>
 
@@ skipping 207 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, public:
 
 // static
 Shell* Shell::CreateInstance(const ShellInitParams& init_params) {
   CHECK(!instance_);
   ShellPort* shell_port = init_params.shell_port;
   if (!shell_port)
     shell_port = new ShellPortClassic();
-  instance_ = new Shell(base::WrapUnique<ShellDelegate>(init_params.delegate),

[msw, 2017/04/12 17:46:59]

q: Is there a reason for changing when Shell::instance_ is assigned in this CL?
It seems fine (nothing appears instantiate a Shell instance without calling
CreateInstance), but it seems slightly odd to include in this CL.

[sky, 2017/04/12 17:53:18]

Ya, sorry, good question. The issue is that GetAshConfig() is called from the
constructor (line 575). But I think assigning instance_ in the constructor is a
bit risky. So, I changed the code back to what it was and in the constructor it
uses shell_port_->GetAshConfig() directly.

[msw, 2017/04/12 18:03:08]

Gotcha.

-                        base::WrapUnique<ShellPort>(shell_port));
-  instance_->Init(init_params);
-  return instance_;
+  Shell* shell =
+      new Shell(base::WrapUnique<ShellDelegate>(init_params.delegate),
+                base::WrapUnique<ShellPort>(shell_port));
+  shell->Init(init_params);
+  return shell;
 }
 
 // static
 Shell* Shell::Get() {
   CHECK(instance_);
   return instance_;
 }
 
 // static
 bool Shell::HasInstance() {
@@ skipping 114 matching lines @@
     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(!shell_port_->IsRunningInMash());
+  DCHECK(GetAshConfig() != Config::MASH);
   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() {
@@ skipping 187 matching lines @@
       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 ShellPortClassic. http://crbug.com/671246.
 
-  if (!shell_port_->IsRunningInMash()) {
+  instance_ = this;
+
+  if (GetAshConfig() != Config::MASH) {
     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);
 }
@@ skipping 177 matching lines @@
   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 = 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 (shell_port_->IsRunningInMash() && shell_delegate_->GetShellConnector()) {
+  if (config == Config::MASH && 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 ShellPort during their construction. Create them here
   // instead of the ShellPort constructor.
@@ skipping 13 matching lines @@
     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)
+  if (config == Config::MASH)
     app_list_delegate_impl_ = base::MakeUnique<AppListDelegateImpl>();
 
   // TODO(sky): move creation to ShellPort.
-  if (!is_mash)
+  if (config != Config::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;
     cursor_manager_.reset(
@@ skipping 75 matching lines @@
   // FocusController takes ownership of AshFocusRules.
   focus_controller_ =
       base::MakeUnique<::wm::FocusController>(new wm::AshFocusRules());
   focus_controller_->AddObserver(this);
 
   screen_position_controller_.reset(new ScreenPositionController);
 
   shell_port_->CreatePrimaryHost();
   root_window_for_new_windows_ = WmWindow::Get(GetPrimaryRootWindow());
 
-  if (!is_mash) {
+  if (config != Config::MASH) {
     resolution_notification_controller_.reset(
         new ResolutionNotificationController);
   }
 
   if (cursor_manager_) {
     cursor_manager_->SetDisplay(
         display::Screen::GetScreen()->GetPrimaryDisplay());
   }
 
   accelerator_controller_ = shell_port_->CreateAcceleratorController();
@@ skipping 25 matching lines @@
       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_ =
       base::MakeUnique<ToplevelWindowEventHandler>();
 
-  if (!is_mash) {
+  if (config != Config::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_ =
       base::MakeUnique<LockStateController>(shutdown_controller_.get());
   power_button_controller_.reset(
       new PowerButtonController(lock_state_controller_.get()));
   // Pass the initial display state to PowerButtonController.
   power_button_controller_->OnDisplayModeChanged(
       display_configurator_->cached_displays());
 
   AddShellObserver(lock_state_controller_.get());
 
   // The connector is unavailable in some tests.
-  if (is_mash && shell_delegate_->GetShellConnector()) {
+  if (config == Config::MASH && shell_delegate_->GetShellConnector()) {
     ui::mojom::UserActivityMonitorPtr user_activity_monitor;
     shell_delegate_->GetShellConnector()->BindInterface(ui::mojom::kServiceName,
                                                         &user_activity_monitor);
     user_activity_forwarder_ = base::MakeUnique<aura::UserActivityForwarder>(
         std::move(user_activity_monitor), user_activity_detector_.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
@@ skipping 43 matching lines @@
   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) {
+  if (config != Config::MASH) {
     touch_transformer_controller_.reset(new AshTouchTransformController(
         display_configurator_.get(), display_manager_.get()));
   }
 
   keyboard_ui_ = shell_port_->CreateKeyboardUI();
 
   shell_port_->InitHosts(init_params);
 
   // Needs to be created after InitDisplays() since it may cause the virtual
   // keyboard to be deployed.
-  if (!is_mash)
+  if (config != Config::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.
   // Also, initialize after display initialization to ensure correct sizing.
   wallpaper_delegate_->InitializeWallpaper();
 
   if (cursor_manager_) {
     if (initially_hide_cursor_)
       cursor_manager_->HideCursor();
     cursor_manager_->SetCursor(ui::kCursorPointer);
   }
 
   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);
-  if (!is_mash) {
+  if (config != Config::MASH) {
     screen_orientation_controller_.reset(new ScreenOrientationController());
     screen_layout_observer_.reset(new ScreenLayoutObserver());
   }
   sms_observer_.reset(new SmsObserver());
 
   // 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.
-  if (!is_mash)
+  if (config != Config::MASH)
     display_manager_->CreateMirrorWindowAsyncIfAny();
 
   for (auto& observer : shell_observers_)
     observer.OnShellInitialized();
 
-  if (!is_mash)
+  if (config != Config::MASH)
     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(
@@ skipping 111 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 (!shell_port_->IsRunningInMash()) {
+    if (GetAshConfig() != Config::MASH) {
       // 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.
@@ skipping 19 matching lines @@
 
 void Shell::OnPrefServiceInitialized(
     std::unique_ptr<::PrefService> pref_service) {
   if (!instance_)
     return;
   DCHECK(pref_service);
   pref_service_ = std::move(pref_service);
 }
 
 }  // namespace ash