Moves maintaining ShellObservers back to Shell

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 10 matching lines @@
 #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/shell_observer.h"
 #include "ash/common/system/chromeos/bluetooth/bluetooth_notification_controller.h"
 #include "ash/common/system/chromeos/network/sms_observer.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"
@@ skipping 240 matching lines @@
   // 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);
 }
 
 void Shell::OnLoginStateChanged(LoginStatus status) {
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnLoginStateChanged(status);
 }
 
 void Shell::OnAppTerminating() {
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnAppTerminating();
 }
 
 void Shell::OnLockStateChanged(bool locked) {
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnLockStateChanged(locked);
 #ifndef NDEBUG
   // Make sure that there is no system modal in Lock layer when unlocked.
   if (!locked) {
     std::vector<WmWindow*> containers = wm::GetContainersFromAllRootWindows(
         kShellWindowId_LockSystemModalContainer,
         WmWindow::Get(GetPrimaryRootWindow()));
     for (WmWindow* container : containers)
       DCHECK(container->GetChildren().empty());
   }
 #endif
 }
 
 void Shell::OnCastingSessionStartedOrStopped(bool started) {
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnCastingSessionStartedOrStopped(started);
 }
 
 void Shell::OnRootWindowAdded(WmWindow* root_window) {
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnRootWindowAdded(root_window);
 }
 
 void Shell::CreateKeyboard() {
   InitKeyboard();
   GetPrimaryRootWindowController()->ActivateKeyboard(
       keyboard::KeyboardController::GetInstance());
 }
 
 void Shell::DeactivateKeyboard() {
@@ skipping 33 matching lines @@
 
 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())
+  for (auto& observer : shell_observers_)
     observer.OnTouchHudProjectionToggled(enabled);
 }
 
 FirstRunHelper* Shell::CreateFirstRunHelper() {
   return new FirstRunHelperImpl;
 }
 
 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) {
   window_tree_host_manager_->cursor_window_controller()
       ->SetCursorCompositingEnabled(enabled);
   native_cursor_manager_->SetNativeCursorEnabled(!enabled);
 }
 
 void Shell::DoInitialWorkspaceAnimation() {
   return GetPrimaryRootWindowController()
       ->workspace_controller()
       ->DoInitialAnimation();
 }
 
+void Shell::AddShellObserver(ShellObserver* observer) {
+  shell_observers_.AddObserver(observer);
+}
+
+void Shell::RemoveShellObserver(ShellObserver* observer) {
+  shell_observers_.RemoveObserver(observer);
+}
+
+void Shell::OnMaximizeModeStarted() {
+  for (auto& observer : shell_observers_)
+    observer.OnMaximizeModeStarted();
+}
+
+void Shell::OnMaximizeModeEnding() {
+  for (auto& observer : shell_observers_)
+    observer.OnMaximizeModeEnding();
+}
+
+void Shell::OnMaximizeModeEnded() {
+  for (auto& observer : shell_observers_)
+    observer.OnMaximizeModeEnded();
+}
+
+void Shell::OnOverviewModeStarting() {
+  for (auto& observer : shell_observers_)
+    observer.OnOverviewModeStarting();
+}
+
+void Shell::OnOverviewModeEnded() {
+  for (auto& observer : shell_observers_)
+    observer.OnOverviewModeEnded();
+}
+
+void Shell::NotifyFullscreenStateChanged(bool is_fullscreen,
+                                         WmWindow* root_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnFullscreenStateChanged(is_fullscreen, root_window);
+}
+
+void Shell::NotifyPinnedStateChanged(WmWindow* pinned_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnPinnedStateChanged(pinned_window);
+}
+
+void Shell::NotifyVirtualKeyboardActivated(bool activated) {
+  for (auto& observer : shell_observers_)
+    observer.OnVirtualKeyboardStateChanged(activated);
+}
+
+void Shell::NotifyShelfCreatedForRootWindow(WmWindow* root_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnShelfCreatedForRootWindow(root_window);
+}
+
+void Shell::NotifyShelfAlignmentChanged(WmWindow* root_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnShelfAlignmentChanged(root_window);
+}
+
+void Shell::NotifyShelfAutoHideBehaviorChanged(WmWindow* root_window) {
+  for (auto& observer : shell_observers_)
+    observer.OnShelfAutoHideBehaviorChanged(root_window);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, private:
 
 Shell::Shell(std::unique_ptr<WmShell> wm_shell)
     : wm_shell_(std::move(wm_shell)),
       link_handler_model_factory_(nullptr),
       activation_client_(nullptr),
       display_configurator_(new display::DisplayConfigurator()),
       native_cursor_manager_(nullptr),
       simulate_modal_window_open_for_testing_(false),
@@ skipping 148 matching lines @@
 
   keyboard::KeyboardController::ResetInstance(nullptr);
 
   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());
+    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.
@@ skipping 43 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_->AddShellObserver(projecting_observer_.get());
+  AddShellObserver(projecting_observer_.get());
 
   if (!display_initialized && chromeos::IsRunningAsSystemCompositor()) {
     display_change_observer_ = base::MakeUnique<display::DisplayChangeObserver>(
         display_configurator_.get(), display_manager_.get());
 
     shutdown_observer_ =
         base::MakeUnique<ShutdownObserver>(display_configurator_.get());
 
     // Register |display_change_observer_| first so that the rest of
     // observer gets invoked after the root windows are configured.
@@ skipping 76 matching lines @@
   AddPreTargetHandler(speech_feedback_handler_.get());
 
   // 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());
+  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(
@@ skipping 11 matching lines @@
   }
 
   lock_state_controller_ =
       base::MakeUnique<LockStateController>(wm_shell_->shutdown_controller());
   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());
 
-  wm_shell_->AddShellObserver(lock_state_controller_.get());
+  AddShellObserver(lock_state_controller_.get());
 
   // The connector is unavailable in some tests.
   if (is_mash && wm_shell_->delegate()->GetShellConnector()) {
     ui::mojom::UserActivityMonitorPtr user_activity_monitor;
     wm_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());
   }
 
@@ skipping 88 matching lines @@
     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)
     display_manager_->CreateMirrorWindowAsyncIfAny();
 
-  for (auto& observer : *wm_shell_->shell_observers())
+  for (auto& observer : shell_observers_)
     observer.OnShellInitialized();
 
   if (!is_mash)
     user_metrics_recorder_->OnShellInitialized();
 }
 
 void Shell::InitKeyboard() {
   if (keyboard::IsKeyboardEnabled()) {
     if (keyboard::KeyboardController::GetInstance()) {
       RootWindowControllerList controllers = GetAllRootWindowControllers();
@@ skipping 72 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