Folds methods in WmShellCommon to WmShell

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 12 matching lines @@
 #include "ash/common/shelf/shelf_item_delegate_manager.h"
 #include "ash/common/shelf/shelf_model.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/locale/locale_notification_controller.h"
 #include "ash/common/system/tray/system_tray_delegate.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/window_positioner.h"
 #include "ash/common/wm_shell.h"
-#include "ash/common/wm_shell_common.h"
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/display/cursor_window_controller.h"
 #include "ash/display/display_configuration_controller.h"
 #include "ash/display/display_manager.h"
 #include "ash/display/event_transformation_handler.h"
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/display/screen_position_controller.h"
 #include "ash/display/window_tree_host_manager.h"
@@ skipping 300 matching lines @@
   // Use translucent-style window frames for dialogs.
   return new CustomFrameViewAsh(widget);
 }
 
 void Shell::SetDisplayWorkAreaInsets(Window* contains,
                                      const gfx::Insets& insets) {
   if (!window_tree_host_manager_->UpdateWorkAreaOfDisplayNearestWindow(
           contains, insets)) {
     return;
   }
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnDisplayWorkAreaInsetsChanged());
 }
 
 void Shell::OnLoginStateChanged(LoginStatus status) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnLoginStateChanged(status));
 }
 
 void Shell::OnLoginUserProfilePrepared() {
   CreateShelf();
   CreateKeyboard();
 }
 
 void Shell::UpdateAfterLoginStatusChange(LoginStatus status) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->UpdateAfterLoginStatusChange(status);
 }
 
 void Shell::OnAppTerminating() {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnAppTerminating());
 }
 
 void Shell::OnLockStateChanged(bool locked) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnLockStateChanged(locked));
 #ifndef NDEBUG
   // Make sure that there is no system modal in Lock layer when unlocked.
   if (!locked) {
     std::vector<aura::Window*> containers = GetContainersFromAllRootWindows(
         kShellWindowId_LockSystemModalContainer, GetPrimaryRootWindow());
     for (std::vector<aura::Window*>::const_iterator iter = containers.begin();
          iter != containers.end(); ++iter) {
       DCHECK_EQ(0u, (*iter)->children().size());
     }
   }
 #endif
 }
 
 void Shell::OnCastingSessionStartedOrStopped(bool started) {
 #if defined(OS_CHROMEOS)
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnCastingSessionStartedOrStopped(started));
 #endif
 }
 
 void Shell::OnMaximizeModeStarted() {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnMaximizeModeStarted());
 }
 
 void Shell::OnMaximizeModeEnded() {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnMaximizeModeEnded());
 }
 
 void Shell::OnRootWindowAdded(WmWindow* root_window) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnRootWindowAdded(root_window));
 }
 
 void Shell::CreateShelf() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->CreateShelf();
 }
 
 void Shell::OnShelfCreatedForRootWindow(WmWindow* root_window) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnShelfCreatedForRootWindow(root_window));
 }
 
 void Shell::CreateKeyboard() {
   if (in_mus_)
     return;
   // TODO(bshe): Primary root window controller may not be the controller to
   // attach virtual keyboard. See http://crbug.com/303429
   InitKeyboard();
   GetPrimaryRootWindowController()->ActivateKeyboard(
@@ skipping 49 matching lines @@
 
 void Shell::UpdateShelfVisibility() {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     if ((*iter)->shelf_widget())
       (*iter)->UpdateShelfVisibility();
 }
 
 void Shell::OnShelfAlignmentChanged(WmWindow* root_window) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnShelfAlignmentChanged(root_window));
 }
 
 void Shell::OnShelfAutoHideBehaviorChanged(WmWindow* root_window) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnShelfAutoHideBehaviorChanged(root_window));
 }
 
 void Shell::NotifyFullscreenStateChange(bool is_fullscreen,
                                         WmWindow* root_window) {
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnFullscreenStateChanged(is_fullscreen, root_window));
 }
 
 void Shell::CreateModalBackground(aura::Window* window) {
   if (!modality_filter_) {
     modality_filter_.reset(new SystemModalContainerEventFilter(this));
     AddPreTargetHandler(modality_filter_.get());
   }
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
@@ skipping 56 matching lines @@
         shelf_model_.get(), shelf_item_delegate_manager_.get()));
   }
   return shelf_delegate_.get();
 }
 
 void Shell::SetTouchHudProjectionEnabled(bool enabled) {
   if (is_touch_hud_projection_enabled_ == enabled)
     return;
 
   is_touch_hud_projection_enabled_ = enabled;
-  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnTouchHudProjectionToggled(enabled));
 }
 
 #if defined(OS_CHROMEOS)
 FirstRunHelper* Shell::CreateFirstRunHelper() {
   return new FirstRunHelperImpl;
 }
 
 void Shell::SetCursorCompositingEnabled(bool enabled) {
   window_tree_host_manager_->cursor_window_controller()
@@ skipping 127 matching lines @@
 
   // |shelf_window_watcher_| has a weak pointer to |shelf_Model_|
   // and has window observers.
   shelf_window_watcher_.reset();
 
   // Destroy all child windows including widgets.
   window_tree_host_manager_->CloseChildWindows();
   // MruWindowTracker must be destroyed after all windows have been deleted to
   // avoid a possible crash when Shell is destroyed from a non-normal shutdown
   // path. (crbug.com/485438).
-  wm_shell_common_->DeleteMruWindowTracker();
+  wm_shell_->DeleteMruWindowTracker();
 
   // Chrome implementation of shelf delegate depends on FocusClient,
   // so must be deleted before |focus_client_| (below).
   shelf_delegate_.reset();
 
   // These need a valid Shell instance to clean up properly, so explicitly
   // delete them before invalidating the instance.
   // Alphabetical. TODO(oshima): sort.
   magnification_controller_.reset();
   partial_magnification_controller_.reset();
@@ skipping 47 matching lines @@
   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_common_->RemoveShellObserver(projecting_observer_.get());
+    wm_shell_->RemoveShellObserver(projecting_observer_.get());
   }
   display_change_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();
 
-  // Must happen after |wm_shell_| is deleted.
-  wm_shell_common_.reset();
-
   DCHECK(instance_ == this);
   instance_ = nullptr;
 }
 
 void Shell::Init(const ShellInitParams& init_params) {
   in_mus_ = init_params.in_mus;
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   DCHECK(in_mus_) << "linux desktop does not support ash.";
 #endif
 
-  wm_shell_common_.reset(new WmShellCommon);
-  wm_shell_.reset(new WmShellAura(wm_shell_common_.get()));
+  wm_shell_.reset(new WmShellAura);
   scoped_overview_animation_settings_factory_.reset(
       new ScopedOverviewAnimationSettingsFactoryAura);
   window_positioner_.reset(new WindowPositioner(wm_shell_.get()));
 
   if (!in_mus_) {
     native_cursor_manager_ = new AshNativeCursorManager;
 #if defined(OS_CHROMEOS)
     cursor_manager_.reset(
         new CursorManager(base::WrapUnique(native_cursor_manager_)));
 #else
@@ skipping 24 matching lines @@
         !gpu_support_->IsPanelFittingDisabled());
 #endif
   }
 
   // The DBusThreadManager must outlive this Shell. See the DCHECK in ~Shell.
   chromeos::DBusThreadManager* dbus_thread_manager =
       chromeos::DBusThreadManager::Get();
   projecting_observer_.reset(
       new ProjectingObserver(dbus_thread_manager->GetPowerManagerClient()));
   display_configurator_->AddObserver(projecting_observer_.get());
-  wm_shell_common_->AddShellObserver(projecting_observer_.get());
+  wm_shell_->AddShellObserver(projecting_observer_.get());
 
   if (!in_mus_ && !display_initialized &&
       base::SysInfo::IsRunningOnChromeOS()) {
     display_change_observer_.reset(new DisplayChangeObserver);
     // Register |display_change_observer_| first so that the rest of
     // observer gets invoked after the root windows are configured.
     display_configurator_->AddObserver(display_change_observer_.get());
     display_error_observer_.reset(new DisplayErrorObserver());
     display_configurator_->AddObserver(display_error_observer_.get());
     display_configurator_->set_state_controller(display_change_observer_.get());
@@ skipping 63 matching lines @@
 #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_common_->AddShellObserver(overlay_filter_.get());
+  wm_shell_->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()));
 
   system_gesture_filter_.reset(new SystemGestureEventFilter);
   AddPreTargetHandler(system_gesture_filter_.get());
 
   keyboard_metrics_filter_.reset(new KeyboardUMAEventFilter);
   AddPreTargetHandler(keyboard_metrics_filter_.get());
 
 #if defined(OS_CHROMEOS)
   sticky_keys_controller_.reset(new StickyKeysController);
 #endif
-  screen_pinning_controller_.reset(new ScreenPinningController(
-      wm_shell_common_.get(), window_tree_host_manager_.get()));
+  screen_pinning_controller_.reset(
+      new ScreenPinningController(window_tree_host_manager_.get()));
 
   lock_state_controller_.reset(new LockStateController);
   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_common_->AddShellObserver(lock_state_controller_.get());
+  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);
 
   magnification_controller_.reset(MagnificationController::CreateInstance());
-  wm_shell_common_->CreateMruWindowTracker();
+  wm_shell_->CreateMruWindowTracker();
 
   partial_magnification_controller_.reset(new PartialMagnificationController());
 
   autoclick_controller_.reset(AutoclickController::CreateInstance());
 
   high_contrast_controller_.reset(new HighContrastController);
   video_detector_.reset(new VideoDetector);
   window_cycle_controller_.reset(new WindowCycleController());
 
   tooltip_controller_.reset(new views::corewm::TooltipController(
@@ skipping 76 matching lines @@
   video_activity_notifier_.reset(
       new VideoActivityNotifier(video_detector_.get()));
   bluetooth_notification_controller_.reset(new BluetoothNotificationController);
   screen_orientation_controller_.reset(new ScreenOrientationController());
 #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_EACH_OBSERVER(ShellObserver, *wm_shell_common_->shell_observers(),
+  FOR_EACH_OBSERVER(ShellObserver, *wm_shell_->shell_observers(),
                     OnShellInitialized());
 
   user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
   if (in_mus_)
     return;
 
   if (keyboard::IsKeyboardEnabled()) {
@@ skipping 68 matching lines @@
 
 void Shell::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (gained_active)
     target_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash