diff options
40 files changed, 326 insertions, 153 deletions
diff --git a/ash/content/display/screen_orientation_controller_chromeos.cc b/ash/content/display/screen_orientation_controller_chromeos.cc index b0b28b3..0e63f65 100644 --- a/ash/content/display/screen_orientation_controller_chromeos.cc +++ b/ash/content/display/screen_orientation_controller_chromeos.cc @@ -128,8 +128,10 @@ void ScreenOrientationController::SetDisplayRotation( } } -void ScreenOrientationController::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void ScreenOrientationController::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { ApplyLockForActiveWindow(); } diff --git a/ash/content/display/screen_orientation_controller_chromeos.h b/ash/content/display/screen_orientation_controller_chromeos.h index 93ac053..93a100d 100644 --- a/ash/content/display/screen_orientation_controller_chromeos.h +++ b/ash/content/display/screen_orientation_controller_chromeos.h @@ -76,8 +76,10 @@ class ASH_EXPORT ScreenOrientationController gfx::Display::RotationSource source); // aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // aura::WindowObserver: void OnWindowVisibilityChanged(aura::Window* window, bool visible) override; diff --git a/ash/display/display_controller_unittest.cc b/ash/display/display_controller_unittest.cc index 273b461..6b04077 100644 --- a/ash/display/display_controller_unittest.cc +++ b/ash/display/display_controller_unittest.cc @@ -114,8 +114,10 @@ class TestObserver : public DisplayController::Observer, } // Overridden from aura::client::ActivationChangeObserver - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override { + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override { activation_changed_count_++; } void OnAttemptToReactivateWindow(aura::Window* request_active, diff --git a/ash/shelf/shelf_layout_manager.cc b/ash/shelf/shelf_layout_manager.cc index e41b349..75e273b 100644 --- a/ash/shelf/shelf_layout_manager.cc +++ b/ash/shelf/shelf_layout_manager.cc @@ -529,8 +529,10 @@ void ShelfLayoutManager::OnLockStateChanged(bool locked) { UpdateShelfVisibilityAfterLoginUIChange(); } -void ShelfLayoutManager::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void ShelfLayoutManager::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { UpdateAutoHideStateNow(); } diff --git a/ash/shelf/shelf_layout_manager.h b/ash/shelf/shelf_layout_manager.h index 240e765..40e1355 100644 --- a/ash/shelf/shelf_layout_manager.h +++ b/ash/shelf/shelf_layout_manager.h @@ -176,8 +176,10 @@ class ASH_EXPORT ShelfLayoutManager void OnLockStateChanged(bool locked) override; // Overriden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // Overridden from ash::LockStateObserver: void OnLockStateEvent(LockStateObserver::EventType event) override; diff --git a/ash/shelf/shelf_window_watcher.cc b/ash/shelf/shelf_window_watcher.cc index 3744687..546d212 100644 --- a/ash/shelf/shelf_window_watcher.cc +++ b/ash/shelf/shelf_window_watcher.cc @@ -190,8 +190,10 @@ void ShelfWindowWatcher::FinishObservingRemovedWindow(aura::Window* window) { RemoveShelfItem(window); } -void ShelfWindowWatcher::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void ShelfWindowWatcher::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { if (gained_active && HasShelfItemForWindow(gained_active)) UpdateShelfItemStatus(gained_active, true); if (lost_active && HasShelfItemForWindow(lost_active)) diff --git a/ash/shelf/shelf_window_watcher.h b/ash/shelf/shelf_window_watcher.h index 28c9b22..c9ffcbf 100644 --- a/ash/shelf/shelf_window_watcher.h +++ b/ash/shelf/shelf_window_watcher.h @@ -103,8 +103,10 @@ class ShelfWindowWatcher : public aura::client::ActivationChangeObserver, void FinishObservingRemovedWindow(aura::Window* window); // aura::client::ActivationChangeObserver overrides: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // aura::WindowObserver overrides: void OnWindowAdded(aura::Window* window) override; diff --git a/ash/shell.cc b/ash/shell.cc index fb61b55..8393cda 100644 --- a/ash/shell.cc +++ b/ash/shell.cc @@ -1177,8 +1177,10 @@ void Shell::OnEvent(ui::Event* event) { //////////////////////////////////////////////////////////////////////////////// // Shell, aura::client::ActivationChangeObserver implementation: -void Shell::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +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(); } diff --git a/ash/shell.h b/ash/shell.h index 41af348..bba346b 100644 --- a/ash/shell.h +++ b/ash/shell.h @@ -617,8 +617,10 @@ class ASH_EXPORT Shell : public SystemModalContainerEventFilterDelegate, void OnEvent(ui::Event* event) override; // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; static Shell* instance_; diff --git a/ash/test/test_activation_delegate.cc b/ash/test/test_activation_delegate.cc index f583a05..6f8caef 100644 --- a/ash/test/test_activation_delegate.cc +++ b/ash/test/test_activation_delegate.cc @@ -44,8 +44,10 @@ bool TestActivationDelegate::ShouldActivate() const { return activate_; } -void TestActivationDelegate::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void TestActivationDelegate::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { DCHECK(window_ == gained_active || window_ == lost_active); if (window_ == gained_active) { activated_count_++; diff --git a/ash/test/test_activation_delegate.h b/ash/test/test_activation_delegate.h index 702e4f9..9c3ddbb 100644 --- a/ash/test/test_activation_delegate.h +++ b/ash/test/test_activation_delegate.h @@ -44,8 +44,10 @@ class TestActivationDelegate : public aura::client::ActivationDelegate, private: // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; aura::Window* window_; bool window_was_active_; diff --git a/ash/wm/dock/docked_window_layout_manager.cc b/ash/wm/dock/docked_window_layout_manager.cc index 91fe6c8..63e8090 100644 --- a/ash/wm/dock/docked_window_layout_manager.cc +++ b/ash/wm/dock/docked_window_layout_manager.cc @@ -902,8 +902,10 @@ void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) { // DockedWindowLayoutManager, aura::client::ActivationChangeObserver // implementation: -void DockedWindowLayoutManager::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void DockedWindowLayoutManager::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { if (gained_active && IsPopupOrTransient(gained_active)) return; // Ignore if the window that is not managed by this was activated. diff --git a/ash/wm/dock/docked_window_layout_manager.h b/ash/wm/dock/docked_window_layout_manager.h index c2a2afa..4fcad6b7 100644 --- a/ash/wm/dock/docked_window_layout_manager.h +++ b/ash/wm/dock/docked_window_layout_manager.h @@ -179,8 +179,10 @@ class ASH_EXPORT DockedWindowLayoutManager void OnWindowDestroying(aura::Window* window) override; // aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; private: class ShelfWindowObserver; diff --git a/ash/wm/mru_window_tracker.cc b/ash/wm/mru_window_tracker.cc index 2c38e0d..00e1773 100644 --- a/ash/wm/mru_window_tracker.cc +++ b/ash/wm/mru_window_tracker.cc @@ -174,8 +174,10 @@ void MruWindowTracker::SetActiveWindow(aura::Window* active_window) { mru_windows_.push_front(active_window); } -void MruWindowTracker::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void MruWindowTracker::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { if (!ignore_window_activations_) SetActiveWindow(gained_active); } diff --git a/ash/wm/mru_window_tracker.h b/ash/wm/mru_window_tracker.h index f32f708..06673a8 100644 --- a/ash/wm/mru_window_tracker.h +++ b/ash/wm/mru_window_tracker.h @@ -65,8 +65,10 @@ class ASH_EXPORT MruWindowTracker void SetActiveWindow(aura::Window* active_window); // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // Overridden from WindowObserver: void OnWindowDestroyed(aura::Window* window) override; diff --git a/ash/wm/overview/window_selector.cc b/ash/wm/overview/window_selector.cc index 61664d7..5e01d37 100644 --- a/ash/wm/overview/window_selector.cc +++ b/ash/wm/overview/window_selector.cc @@ -505,8 +505,10 @@ void WindowSelector::OnWindowDestroying(aura::Window* window) { restore_focus_window_ = nullptr; } -void WindowSelector::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void WindowSelector::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { if (ignore_activations_ || !gained_active || gained_active == text_filter_widget_->GetNativeWindow()) { @@ -534,7 +536,9 @@ void WindowSelector::OnWindowActivated(aura::Window* gained_active, void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active, aura::Window* actual_active) { - OnWindowActivated(request_active, actual_active); + OnWindowActivated(aura::client::ActivationChangeObserver::ActivationReason:: + ACTIVATION_CLIENT, + request_active, actual_active); } void WindowSelector::ContentsChanged(views::Textfield* sender, diff --git a/ash/wm/overview/window_selector.h b/ash/wm/overview/window_selector.h index 7c783b8..06cfb1b 100644 --- a/ash/wm/overview/window_selector.h +++ b/ash/wm/overview/window_selector.h @@ -102,8 +102,10 @@ class ASH_EXPORT WindowSelector void OnWindowDestroying(aura::Window* window) override; // aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; void OnAttemptToReactivateWindow(aura::Window* request_active, aura::Window* actual_active) override; diff --git a/ash/wm/panels/panel_layout_manager.cc b/ash/wm/panels/panel_layout_manager.cc index 35219d5..11f2c1d 100644 --- a/ash/wm/panels/panel_layout_manager.cc +++ b/ash/wm/panels/panel_layout_manager.cc @@ -513,8 +513,10 @@ void PanelLayoutManager::OnPostWindowStateTypeChange( //////////////////////////////////////////////////////////////////////////////// // PanelLayoutManager, aura::client::ActivationChangeObserver implementation: -void PanelLayoutManager::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void PanelLayoutManager::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { // Ignore if the panel that is not managed by this was activated. if (gained_active && gained_active->type() == ui::wm::WINDOW_TYPE_PANEL && gained_active->parent() == panel_container_) { diff --git a/ash/wm/panels/panel_layout_manager.h b/ash/wm/panels/panel_layout_manager.h index 1a2dadb..427e5f1 100644 --- a/ash/wm/panels/panel_layout_manager.h +++ b/ash/wm/panels/panel_layout_manager.h @@ -108,8 +108,10 @@ class ASH_EXPORT PanelLayoutManager wm::WindowStateType old_type) override; // Overridden from aura::client::ActivationChangeObserver - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // Overridden from DisplayController::Observer void OnDisplayConfigurationChanged() override; diff --git a/ash/wm/workspace/workspace_layout_manager.cc b/ash/wm/workspace/workspace_layout_manager.cc index 63c4aed..6db10ec 100644 --- a/ash/wm/workspace/workspace_layout_manager.cc +++ b/ash/wm/workspace/workspace_layout_manager.cc @@ -245,8 +245,10 @@ void WorkspaceLayoutManager::OnWindowBoundsChanged(aura::Window* window, // WorkspaceLayoutManager, // aura::client::ActivationChangeObserver implementation: -void WorkspaceLayoutManager::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void WorkspaceLayoutManager::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { wm::WindowState* window_state = wm::GetWindowState(gained_active); if (window_state && window_state->IsMinimized() && !gained_active->IsVisible()) { diff --git a/ash/wm/workspace/workspace_layout_manager.h b/ash/wm/workspace/workspace_layout_manager.h index 5570dd5..d5e57ec 100644 --- a/ash/wm/workspace/workspace_layout_manager.h +++ b/ash/wm/workspace/workspace_layout_manager.h @@ -84,8 +84,10 @@ class ASH_EXPORT WorkspaceLayoutManager const gfx::Rect& new_bounds) override; // aura::client::ActivationChangeObserver overrides: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // keyboard::KeyboardControllerObserver overrides: void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override; diff --git a/chrome/browser/ui/ash/launcher/app_window_launcher_controller.cc b/chrome/browser/ui/ash/launcher/app_window_launcher_controller.cc index ac0ae5f..ee37e65 100644 --- a/chrome/browser/ui/ash/launcher/app_window_launcher_controller.cc +++ b/chrome/browser/ui/ash/launcher/app_window_launcher_controller.cc @@ -127,8 +127,10 @@ void AppWindowLauncherController::OnWindowDestroying(aura::Window* window) { UnregisterApp(window); } -void AppWindowLauncherController::OnWindowActivated(aura::Window* new_active, - aura::Window* old_active) { +void AppWindowLauncherController::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* new_active, + aura::Window* old_active) { // Make the newly active window the active (first) entry in the controller. AppWindowLauncherItemController* new_controller = ControllerForWindow(new_active); diff --git a/chrome/browser/ui/ash/launcher/app_window_launcher_controller.h b/chrome/browser/ui/ash/launcher/app_window_launcher_controller.h index 4ff452e..a4993dc 100644 --- a/chrome/browser/ui/ash/launcher/app_window_launcher_controller.h +++ b/chrome/browser/ui/ash/launcher/app_window_launcher_controller.h @@ -59,8 +59,10 @@ class AppWindowLauncherController void OnWindowDestroying(aura::Window* window) override; // Overriden from client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; protected: // Registers a app window with the shelf and this object. diff --git a/chrome/browser/ui/ash/launcher/browser_status_monitor.cc b/chrome/browser/ui/ash/launcher/browser_status_monitor.cc index 08f96c0..0ef0124 100644 --- a/chrome/browser/ui/ash/launcher/browser_status_monitor.cc +++ b/chrome/browser/ui/ash/launcher/browser_status_monitor.cc @@ -164,8 +164,10 @@ void BrowserStatusMonitor::UpdateBrowserItemState() { UpdateBrowserItemState(); } -void BrowserStatusMonitor::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void BrowserStatusMonitor::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { Browser* browser = NULL; content::WebContents* contents_from_gained = NULL; content::WebContents* contents_from_lost = NULL; diff --git a/chrome/browser/ui/ash/launcher/browser_status_monitor.h b/chrome/browser/ui/ash/launcher/browser_status_monitor.h index b0a4e5b..e7671ba 100644 --- a/chrome/browser/ui/ash/launcher/browser_status_monitor.h +++ b/chrome/browser/ui/ash/launcher/browser_status_monitor.h @@ -56,8 +56,10 @@ class BrowserStatusMonitor : public aura::client::ActivationChangeObserver, void UpdateBrowserItemState(); // aura::client::ActivationChangeObserver overrides: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // aura::WindowObserver overrides: void OnWindowDestroyed(aura::Window* window) override; diff --git a/chrome/browser/ui/views/extensions/extension_popup_aura.cc b/chrome/browser/ui/views/extensions/extension_popup_aura.cc index e3e7c90..7901f3f 100644 --- a/chrome/browser/ui/views/extensions/extension_popup_aura.cc +++ b/chrome/browser/ui/views/extensions/extension_popup_aura.cc @@ -53,8 +53,10 @@ void ExtensionPopupAura::OnWidgetDestroying(views::Widget* widget) { } } -void ExtensionPopupAura::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void ExtensionPopupAura::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { // Close on anchor window activation (ie. user clicked the browser window). // DesktopNativeWidgetAura does not trigger the expected browser widget // [de]activation events when activating widgets in its own root window. diff --git a/chrome/browser/ui/views/extensions/extension_popup_aura.h b/chrome/browser/ui/views/extensions/extension_popup_aura.h index d9b0dbf..d9b8e50 100644 --- a/chrome/browser/ui/views/extensions/extension_popup_aura.h +++ b/chrome/browser/ui/views/extensions/extension_popup_aura.h @@ -21,8 +21,10 @@ class ExtensionPopupAura : public ExtensionPopup, void OnWidgetDestroying(views::Widget* widget) override; // aura::client::ActivationChangeObserver overrides. - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; private: DISALLOW_COPY_AND_ASSIGN(ExtensionPopupAura); diff --git a/ui/views/controls/menu/menu_message_loop_aura.cc b/ui/views/controls/menu/menu_message_loop_aura.cc index 6a16296..3ed3328 100644 --- a/ui/views/controls/menu/menu_message_loop_aura.cc +++ b/ui/views/controls/menu/menu_message_loop_aura.cc @@ -60,8 +60,10 @@ class ActivationChangeObserverImpl ~ActivationChangeObserverImpl() override { Cleanup(); } // aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override { + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override { if (!controller_->drag_in_progress()) controller_->CancelAll(); } diff --git a/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc b/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc index c82ced7..33629f9 100644 --- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc +++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc @@ -1111,8 +1111,10 @@ bool DesktopNativeWidgetAura::ShouldActivate() const { // DesktopNativeWidgetAura, aura::client::ActivationChangeObserver // implementation: -void DesktopNativeWidgetAura::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void DesktopNativeWidgetAura::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) { DCHECK(content_window_ == gained_active || content_window_ == lost_active); if (gained_active == content_window_ && restore_focus_on_activate_) { restore_focus_on_activate_ = false; diff --git a/ui/views/widget/desktop_aura/desktop_native_widget_aura.h b/ui/views/widget/desktop_aura/desktop_native_widget_aura.h index e92aa84..0419fab 100644 --- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.h +++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.h @@ -213,8 +213,10 @@ class VIEWS_EXPORT DesktopNativeWidgetAura bool ShouldActivate() const override; // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // Overridden from aura::client::FocusChangeObserver: void OnWindowFocused(aura::Window* gained_focus, diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc index bf113e6..92ff22a 100644 --- a/ui/views/widget/native_widget_aura.cc +++ b/ui/views/widget/native_widget_aura.cc @@ -936,8 +936,10 @@ bool NativeWidgetAura::ShouldActivate() const { //////////////////////////////////////////////////////////////////////////////// // NativeWidgetAura, aura::client::ActivationChangeObserver implementation: -void NativeWidgetAura::OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) { +void NativeWidgetAura::OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason, + aura::Window* gained_active, + aura::Window* lost_active) { DCHECK(window_ == gained_active || window_ == lost_active); if (GetWidget()->GetFocusManager()) { if (window_ == gained_active) diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h index 40a9c47..6c38c3e 100644 --- a/ui/views/widget/native_widget_aura.h +++ b/ui/views/widget/native_widget_aura.h @@ -177,8 +177,10 @@ class VIEWS_EXPORT NativeWidgetAura bool ShouldActivate() const override; // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; // Overridden from aura::client::FocusChangeObserver: void OnWindowFocused(aura::Window* gained_focus, diff --git a/ui/wm/core/default_activation_client.cc b/ui/wm/core/default_activation_client.cc index 20c0d79..2a2c23d 100644 --- a/ui/wm/core/default_activation_client.cc +++ b/ui/wm/core/default_activation_client.cc @@ -40,7 +40,7 @@ class DefaultActivationClient::Deleter : public aura::WindowObserver { // DefaultActivationClient, public: DefaultActivationClient::DefaultActivationClient(aura::Window* root_window) - : last_active_(NULL) { + : last_active_(nullptr) { aura::client::SetActivationClient(root_window, this); new Deleter(this, root_window); } @@ -59,6 +59,14 @@ void DefaultActivationClient::RemoveObserver( } void DefaultActivationClient::ActivateWindow(aura::Window* window) { + ActivateWindowImpl(aura::client::ActivationChangeObserver::ActivationReason:: + ACTIVATION_CLIENT, + window); +} + +void DefaultActivationClient::ActivateWindowImpl( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* window) { aura::Window* last_active = GetActiveWindow(); if (last_active == window) return; @@ -69,41 +77,45 @@ void DefaultActivationClient::ActivateWindow(aura::Window* window) { window->parent()->StackChildAtTop(window); window->AddObserver(this); - FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver, - observers_, - OnWindowActivated(window, last_active)); + FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver, observers_, + OnWindowActivated(reason, window, last_active)); aura::client::ActivationChangeObserver* observer = aura::client::GetActivationChangeObserver(last_active); - if (observer) - observer->OnWindowActivated(window, last_active); + if (observer) { + observer->OnWindowActivated(reason, window, last_active); + } observer = aura::client::GetActivationChangeObserver(window); - if (observer) - observer->OnWindowActivated(window, last_active); + if (observer) { + observer->OnWindowActivated(reason, window, last_active); + } } void DefaultActivationClient::DeactivateWindow(aura::Window* window) { aura::client::ActivationChangeObserver* observer = aura::client::GetActivationChangeObserver(window); - if (observer) - observer->OnWindowActivated(NULL, window); + if (observer) { + observer->OnWindowActivated(aura::client::ActivationChangeObserver:: + ActivationReason::ACTIVATION_CLIENT, + nullptr, window); + } if (last_active_) ActivateWindow(last_active_); } aura::Window* DefaultActivationClient::GetActiveWindow() { if (active_windows_.empty()) - return NULL; + return nullptr; return active_windows_.back(); } aura::Window* DefaultActivationClient::GetActivatableWindow( aura::Window* window) { - return NULL; + return nullptr; } aura::Window* DefaultActivationClient::GetToplevelWindow(aura::Window* window) { - return NULL; + return nullptr; } bool DefaultActivationClient::CanActivateWindow(aura::Window* window) const { @@ -115,14 +127,16 @@ bool DefaultActivationClient::CanActivateWindow(aura::Window* window) const { void DefaultActivationClient::OnWindowDestroyed(aura::Window* window) { if (window == last_active_) - last_active_ = NULL; + last_active_ = nullptr; if (window == GetActiveWindow()) { active_windows_.pop_back(); aura::Window* next_active = GetActiveWindow(); if (next_active && aura::client::GetActivationChangeObserver(next_active)) { - aura::client::GetActivationChangeObserver(next_active)->OnWindowActivated( - next_active, NULL); + aura::client::GetActivationChangeObserver(next_active) + ->OnWindowActivated(aura::client::ActivationChangeObserver:: + ActivationReason::WINDOW_DISPOSITION_CHANGED, + next_active, nullptr); } return; } diff --git a/ui/wm/core/default_activation_client.h b/ui/wm/core/default_activation_client.h index b5511457..894bccff 100644 --- a/ui/wm/core/default_activation_client.h +++ b/ui/wm/core/default_activation_client.h @@ -11,6 +11,7 @@ #include "base/logging.h" #include "base/observer_list.h" #include "ui/aura/window_observer.h" +#include "ui/wm/public/activation_change_observer.h" #include "ui/wm/public/activation_client.h" #include "ui/wm/wm_export.h" @@ -51,6 +52,10 @@ class WM_EXPORT DefaultActivationClient : public aura::client::ActivationClient, ~DefaultActivationClient() override; void RemoveActiveWindow(aura::Window* window); + void ActivateWindowImpl( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* window); + // This class explicitly does NOT store the active window in a window property // to make sure that ActivationChangeObserver is not treated as part of the // aura API. Assumptions to that end will cause tests that use this client to diff --git a/ui/wm/core/focus_controller.cc b/ui/wm/core/focus_controller.cc index 446e82c..1fee190 100644 --- a/ui/wm/core/focus_controller.cc +++ b/ui/wm/core/focus_controller.cc @@ -103,38 +103,9 @@ void FocusController::RemoveObserver( } void FocusController::FocusWindow(aura::Window* window) { - if (window && - (window->Contains(focused_window_) || window->Contains(active_window_))) { - return; - } - - // Focusing a window also activates its containing activatable window. Note - // that the rules could redirect activation activation and/or focus. - aura::Window* focusable = rules_->GetFocusableWindow(window); - aura::Window* activatable = - focusable ? rules_->GetActivatableWindow(focusable) : NULL; - - // We need valid focusable/activatable windows in the event we're not clearing - // focus. "Clearing focus" is inferred by whether or not |window| passed to - // this function is non-NULL. - if (window && (!focusable || !activatable)) - return; - DCHECK((focusable && activatable) || !window); - - // Activation change observers may change the focused window. If this happens - // we must not adjust the focus below since this will clobber that change. - aura::Window* last_focused_window = focused_window_; - if (!updating_activation_) - SetActiveWindow(window, activatable); - - // If the window's ActivationChangeObserver shifted focus to a valid window, - // we don't want to focus the window we thought would be focused by default. - bool activation_changed_focus = last_focused_window != focused_window_; - if (!updating_focus_ && (!activation_changed_focus || !focused_window_)) { - if (active_window_ && focusable) - DCHECK(active_window_->Contains(focusable)); - SetFocusedWindow(focusable); - } + FocusAndActivateWindow(aura::client::ActivationChangeObserver:: + ActivationReason::ACTIVATION_CLIENT, + window); } void FocusController::ResetFocusWithinActiveWindow(aura::Window* window) { @@ -213,6 +184,43 @@ void FocusController::OnWindowHierarchyChanged( //////////////////////////////////////////////////////////////////////////////// // FocusController, private: +void FocusController::FocusAndActivateWindow( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* window) { + if (window && + (window->Contains(focused_window_) || window->Contains(active_window_))) { + return; + } + + // Focusing a window also activates its containing activatable window. Note + // that the rules could redirect activation activation and/or focus. + aura::Window* focusable = rules_->GetFocusableWindow(window); + aura::Window* activatable = + focusable ? rules_->GetActivatableWindow(focusable) : NULL; + + // We need valid focusable/activatable windows in the event we're not clearing + // focus. "Clearing focus" is inferred by whether or not |window| passed to + // this function is non-NULL. + if (window && (!focusable || !activatable)) + return; + DCHECK((focusable && activatable) || !window); + + // Activation change observers may change the focused window. If this happens + // we must not adjust the focus below since this will clobber that change. + aura::Window* last_focused_window = focused_window_; + if (!updating_activation_) + SetActiveWindow(reason, window, activatable); + + // If the window's ActivationChangeObserver shifted focus to a valid window, + // we don't want to focus the window we thought would be focused by default. + bool activation_changed_focus = last_focused_window != focused_window_; + if (!updating_focus_ && (!activation_changed_focus || !focused_window_)) { + if (active_window_ && focusable) + DCHECK(active_window_->Contains(focusable)); + SetFocusedWindow(focusable); + } +} + void FocusController::SetFocusedWindow(aura::Window* window) { if (updating_focus_ || window == focused_window_) return; @@ -268,8 +276,10 @@ void FocusController::SetFocusedWindow(aura::Window* window) { text_input_focus_manager->FocusTextInputClient(NULL); } -void FocusController::SetActiveWindow(aura::Window* requested_window, - aura::Window* window) { +void FocusController::SetActiveWindow( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* requested_window, + aura::Window* window) { if (updating_activation_) return; @@ -310,19 +320,19 @@ void FocusController::SetActiveWindow(aura::Window* requested_window, if (window_tracker.Contains(lost_activation)) { observer = aura::client::GetActivationChangeObserver(lost_activation); if (observer) - observer->OnWindowActivated(active_window_, lost_activation); + observer->OnWindowActivated(reason, active_window_, lost_activation); } observer = aura::client::GetActivationChangeObserver(active_window_); if (observer) { observer->OnWindowActivated( - active_window_, + reason, active_window_, window_tracker.Contains(lost_activation) ? lost_activation : NULL); } - FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver, - activation_observers_, - OnWindowActivated(active_window_, - window_tracker.Contains(lost_activation) ? - lost_activation : NULL)); + FOR_EACH_OBSERVER( + aura::client::ActivationChangeObserver, activation_observers_, + OnWindowActivated( + reason, active_window_, + window_tracker.Contains(lost_activation) ? lost_activation : NULL)); } void FocusController::WindowLostFocusFromDispositionChange( @@ -335,7 +345,9 @@ void FocusController::WindowLostFocusFromDispositionChange( // that process so there's no point in updating focus independently. if (window == active_window_) { aura::Window* next_activatable = rules_->GetNextActivatableWindow(window); - SetActiveWindow(NULL, next_activatable); + SetActiveWindow(aura::client::ActivationChangeObserver::ActivationReason:: + WINDOW_DISPOSITION_CHANGED, + NULL, next_activatable); if (!(active_window_ && active_window_->Contains(focused_window_))) SetFocusedWindow(next_activatable); } else if (window->Contains(focused_window_)) { @@ -348,8 +360,11 @@ void FocusController::WindowFocusedFromInputEvent(aura::Window* window) { // Only focus |window| if it or any of its parents can be focused. Otherwise // FocusWindow() will focus the topmost window, which may not be the // currently focused one. - if (rules_->CanFocusWindow(GetToplevelWindow(window))) - FocusWindow(window); + if (rules_->CanFocusWindow(GetToplevelWindow(window))) { + FocusAndActivateWindow( + aura::client::ActivationChangeObserver::ActivationReason::INPUT_EVENT, + window); + } } } // namespace wm diff --git a/ui/wm/core/focus_controller.h b/ui/wm/core/focus_controller.h index be04b49..e00f0b6 100644 --- a/ui/wm/core/focus_controller.h +++ b/ui/wm/core/focus_controller.h @@ -12,6 +12,7 @@ #include "ui/aura/client/focus_client.h" #include "ui/aura/window_observer.h" #include "ui/events/event_handler.h" +#include "ui/wm/public/activation_change_observer.h" #include "ui/wm/public/activation_client.h" #include "ui/wm/wm_export.h" @@ -24,16 +25,19 @@ class FocusRules; // only one focused and one active window at a time. When focus or activation // changes notifications are sent using the // aura::client::Focus/ActivationChangeObserver interfaces. -// Changes to focus and activation can be from three sources: -// . the Aura Client API (implemented here in aura::client::ActivationClient). -// (The FocusController must be set as the ActivationClient implementation -// for all RootWindows). -// . input events (implemented here in ui::EventHandler). -// (The FocusController must be registered as a pre-target handler for -// the applicable environment owner, either a RootWindow or another type). -// . Window disposition changes (implemented here in aura::WindowObserver). -// (The FocusController registers itself as an observer of the active and -// focused windows). +// Changes to focus and activation can be from three sources. The source can be +// determined by the ActivationReason parameter in +// ActivationChangeObserver::OnWindowActivated(...). +// . ActivationReason::ACTIVATION_CLIENT: The Aura Client API (implemented here +// in aura::client::ActivationClient). (The FocusController must be set as the +// ActivationClient implementation for all RootWindows). +// . ActivationReason::INPUT_EVENT: Input events (implemented here in +// ui::EventHandler). (The FocusController must be registered as a pre-target +// handler for the applicable environment owner, either a RootWindow or +// another type). +// . ActivationReason::WINDOW_DISPOSITION_CHANGED: Window disposition changes +// (implemented here in aura::WindowObserver). (The FocusController registers +// itself as an observer of the active and focused windows). class WM_EXPORT FocusController : public aura::client::ActivationClient, public aura::client::FocusClient, public ui::EventHandler, @@ -75,18 +79,26 @@ class WM_EXPORT FocusController : public aura::client::ActivationClient, void OnWindowHierarchyChanging(const HierarchyChangeParams& params) override; void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override; + // Internal implementation that coordinates window focus and activation + // changes. + void FocusAndActivateWindow( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* window); + // Internal implementation that sets the focused window, fires events etc. // This function must be called with a valid focusable window. void SetFocusedWindow(aura::Window* window); // Internal implementation that sets the active window, fires events etc. // This function must be called with a valid |activatable_window|. - // |requested window| refers to the window that was passed in to an external + // |requested_window| refers to the window that was passed in to an external // request (e.g. FocusWindow or ActivateWindow). It may be NULL, e.g. if // SetActiveWindow was not called by an external request. |activatable_window| // refers to the actual window to be activated, which may be different. - void SetActiveWindow(aura::Window* requested_window, - aura::Window* activatable_window); + void SetActiveWindow( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* requested_window, + aura::Window* activatable_window); // Called when a window's disposition changed such that it and its hierarchy // are no longer focusable/activatable. |next| is a valid window that is used diff --git a/ui/wm/core/focus_controller_unittest.cc b/ui/wm/core/focus_controller_unittest.cc index 84c691f..a8bddb3 100644 --- a/ui/wm/core/focus_controller_unittest.cc +++ b/ui/wm/core/focus_controller_unittest.cc @@ -33,7 +33,8 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver, public aura::client::FocusChangeObserver { public: FocusNotificationObserver() - : activation_changed_count_(0), + : last_activation_reason_(ActivationReason::ACTIVATION_CLIENT), + activation_changed_count_(0), focus_changed_count_(0), reactivation_count_(0), reactivation_requested_window_(NULL), @@ -44,6 +45,9 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver, EXPECT_EQ(activation_changed_count, activation_changed_count_); EXPECT_EQ(focus_changed_count, focus_changed_count_); } + ActivationReason last_activation_reason() const { + return last_activation_reason_; + } int reactivation_count() const { return reactivation_count_; } @@ -56,8 +60,10 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver, private: // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, + void OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) override { + last_activation_reason_ = reason; ++activation_changed_count_; } void OnAttemptToReactivateWindow(aura::Window* request_active, @@ -73,6 +79,7 @@ class FocusNotificationObserver : public aura::client::ActivationChangeObserver, ++focus_changed_count_; } + ActivationReason last_activation_reason_; int activation_changed_count_; int focus_changed_count_; int reactivation_count_; @@ -115,7 +122,8 @@ class RecordingActivationAndFocusChangeObserver } // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, + void OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) override { if (lost_active && lost_active == deleter_->GetDeletedWindow()) was_notified_with_deleted_window_ = true; @@ -158,7 +166,8 @@ class DeleteOnLoseActivationChangeObserver : } // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, + void OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) override { if (window_ && lost_active == window_) { delete lost_active; @@ -303,7 +312,8 @@ class FocusShiftingActivationObserver private: // Overridden from aura::client::ActivationChangeObserver: - void OnWindowActivated(aura::Window* gained_active, + void OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) override { // Shift focus to a child. This should prevent the default focusing from // occurring in FocusController::FocusWindow(). @@ -499,6 +509,11 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase { // Input events do not change focus if the window can not be focused. virtual bool IsInputEvent() = 0; + // Returns the expected ActivationReason caused by calling the + // ActivatedWindowDirect(...) or DeactivateWindowDirect(...) methods. + virtual aura::client::ActivationChangeObserver::ActivationReason + GetExpectedActivationReason() const = 0; + void FocusWindowById(int id) { aura::Window* window = root_window()->GetChildById(id); DCHECK(window); @@ -579,6 +594,8 @@ class FocusControllerDirectTestBase : public FocusControllerTestBase { ActivateWindowById(2); root_observer.ExpectCounts(1, 1); + EXPECT_EQ(GetExpectedActivationReason(), + root_observer.last_activation_reason()); observer1.ExpectCounts(1, 1); observer2.ExpectCounts(1, 1); } @@ -895,6 +912,12 @@ class FocusControllerApiTest : public FocusControllerDirectTestBase { DeactivateWindow(window); } bool IsInputEvent() override { return false; } + // Overridden from FocusControllerDirectTestBase: + aura::client::ActivationChangeObserver::ActivationReason + GetExpectedActivationReason() const override { + return aura::client::ActivationChangeObserver::ActivationReason:: + ACTIVATION_CLIENT; + } DISALLOW_COPY_AND_ASSIGN(FocusControllerApiTest); }; @@ -937,7 +960,13 @@ class FocusControllerMouseEventTest : public FocusControllerDirectTestBase { ui::test::EventGenerator generator(root_window(), next_activatable); generator.ClickLeftButton(); } + // Overridden from FocusControllerDirectTestBase: bool IsInputEvent() override { return true; } + aura::client::ActivationChangeObserver::ActivationReason + GetExpectedActivationReason() const override { + return aura::client::ActivationChangeObserver::ActivationReason:: + INPUT_EVENT; + } DISALLOW_COPY_AND_ASSIGN(FocusControllerMouseEventTest); }; @@ -963,6 +992,11 @@ class FocusControllerGestureEventTest : public FocusControllerDirectTestBase { generator.GestureTapAt(window->bounds().CenterPoint()); } bool IsInputEvent() override { return true; } + aura::client::ActivationChangeObserver::ActivationReason + GetExpectedActivationReason() const override { + return aura::client::ActivationChangeObserver::ActivationReason:: + INPUT_EVENT; + } DISALLOW_COPY_AND_ASSIGN(FocusControllerGestureEventTest); }; @@ -978,6 +1012,14 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase { return parent_ ? window->parent() : window; } + // Returns the expected ActivationReason caused by calling the + // ActivatedWindowDirect(...) or DeactivateWindowDirect(...) methods. + aura::client::ActivationChangeObserver::ActivationReason + GetExpectedActivationReason() const { + return aura::client::ActivationChangeObserver::ActivationReason:: + WINDOW_DISPOSITION_CHANGED; + } + // Change the disposition of |window| in such a way as it will lose focus. virtual void ChangeWindowDisposition(aura::Window* window) = 0; @@ -1038,6 +1080,8 @@ class FocusControllerImplicitTestBase : public FocusControllerTestBase { ChangeWindowDisposition(w2); root_observer.ExpectCounts(1, 1); + EXPECT_EQ(GetExpectedActivationReason(), + root_observer.last_activation_reason()); observer2.ExpectCounts(1, 1); observer3.ExpectCounts(1, 1); } diff --git a/ui/wm/core/shadow_controller.cc b/ui/wm/core/shadow_controller.cc index 9ba88d3..1e5dd49 100644 --- a/ui/wm/core/shadow_controller.cc +++ b/ui/wm/core/shadow_controller.cc @@ -113,7 +113,8 @@ class ShadowController::Impl : ~Impl() override; // Forwarded from ShadowController. - void OnWindowActivated(aura::Window* gained_active, + void OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active); // Checks if |window| is visible and contains a property requesting a shadow. @@ -183,7 +184,8 @@ void ShadowController::Impl::OnWindowDestroyed(aura::Window* window) { observer_manager_.Remove(window); } -void ShadowController::Impl::OnWindowActivated(aura::Window* gained_active, +void ShadowController::Impl::OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) { if (gained_active) { Shadow* shadow = GetShadowForWindow(gained_active); @@ -271,9 +273,10 @@ ShadowController::~ShadowController() { activation_client_->RemoveObserver(this); } -void ShadowController::OnWindowActivated(aura::Window* gained_active, +void ShadowController::OnWindowActivated(ActivationReason reason, + aura::Window* gained_active, aura::Window* lost_active) { - impl_->OnWindowActivated(gained_active, lost_active); + impl_->OnWindowActivated(reason, gained_active, lost_active); } // ShadowController::TestApi --------------------------------------------------- diff --git a/ui/wm/core/shadow_controller.h b/ui/wm/core/shadow_controller.h index 360a997..b307c02 100644 --- a/ui/wm/core/shadow_controller.h +++ b/ui/wm/core/shadow_controller.h @@ -51,8 +51,10 @@ class WM_EXPORT ShadowController : ~ShadowController() override; // aura::client::ActivationChangeObserver overrides: - void OnWindowActivated(aura::Window* gained_active, - aura::Window* lost_active) override; + void OnWindowActivated( + aura::client::ActivationChangeObserver::ActivationReason reason, + aura::Window* gained_active, + aura::Window* lost_active) override; private: class Impl; diff --git a/ui/wm/public/activation_change_observer.h b/ui/wm/public/activation_change_observer.h index 68d5b8a..57f9d27 100644 --- a/ui/wm/public/activation_change_observer.h +++ b/ui/wm/public/activation_change_observer.h @@ -14,11 +14,23 @@ namespace client { class AURA_EXPORT ActivationChangeObserver { public: - // Called when |active| gains focus, or there is no active window - // (|active| is NULL in this case.) |old_active| refers to the + // The reason or cause of a window activation change. + enum class ActivationReason { + // When a window is activated due to a call to the ActivationClient API. + ACTIVATION_CLIENT, + // When a user clicks or taps a window in the 2-dimensional screen space. + INPUT_EVENT, + // When a new window is activated as a side effect of a window + // disposition changing. + WINDOW_DISPOSITION_CHANGED, + }; + + // Called when |gained_active| gains focus, or there is no active window + // (|gained_active| is NULL in this case.) |lost_active| refers to the // previous active window or NULL if there was no previously active - // window. - virtual void OnWindowActivated(Window* gained_active, + // window. |reason| specifies the cause of the activation change. + virtual void OnWindowActivated(ActivationReason reason, + Window* gained_active, Window* lost_active) = 0; // Called when during window activation the currently active window is |