Add system ui area observer.

This will be used in an upcoming CL. We want the Picture-in-Picture
window to avoid system ui areas such as the message center and virtual
keyboard. In order to support this, this CL adds a new WM event to fire
when something changes about a 'system ui area,' which currently
includes the virtual keyboard (floating or normal) and the message
center.

Bug: b/115291749
Bug: 841886
Bug: 874545
Bug: b/112668491
Test: Added unittest
Change-Id: Ic3b0cde8800bfc98dd2ffbe0d17137a6e1a26809
Reviewed-on: https://chromium-review.googlesource.com/c/1219366
Commit-Queue: Eliot Courtney <edcourtney@chromium.org>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Cr-Commit-Position: refs/heads/master@{#601832}

ash/wm/default_state.cc

@@ -214,6 +214,8 @@ void DefaultState::HandleWorkspaceEvents(WindowState* window_state,
         window_state->SetBoundsDirectAnimated(bounds);
       return;
     }
+    case WM_EVENT_SYSTEM_UI_AREA_CHANGED:
+      break;
     default:
       NOTREACHED() << "Unknown event:" << event->type();
   }

ash/wm/lock_window_state.cc

@@ -83,6 +83,8 @@ void LockWindowState::OnWMEvent(wm::WindowState* window_state,
     case wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       UpdateBounds(window_state);
       break;
+    case wm::WM_EVENT_SYSTEM_UI_AREA_CHANGED:
+      return;
   }
 }
 

ash/wm/tablet_mode/tablet_mode_window_state.cc

@@ -263,6 +263,7 @@ void TabletModeWindowState::OnWMEvent(wm::WindowState* window_state,
                    true /* animated */);
       return;
     case wm::WM_EVENT_SHOW_INACTIVE:
+    case wm::WM_EVENT_SYSTEM_UI_AREA_CHANGED:
       return;
     case wm::WM_EVENT_SET_BOUNDS: {
       gfx::Rect bounds_in_parent =

ash/wm/wm_event.cc

@@ -19,6 +19,7 @@ bool WMEvent::IsWorkspaceEvent() const {
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
+    case WM_EVENT_SYSTEM_UI_AREA_CHANGED:
       return true;
     default:
       break;

ash/wm/wm_event.h

@@ -94,6 +94,13 @@ enum WMEventType {
   // A user requested to pin a window for a trusted application. This is similar
   // WM_EVENT_PIN but does not allow user to exit the mode by shortcut key.
   WM_EVENT_TRUSTED_PIN,
+
+  // A system ui area has changed. Currently, this includes the virtual
+  // keyboard and the message center. A change can be a change in visibility
+  // or bounds.
+  // TODO(oshima): Consider consolidating this into
+  // WM_EVENT_WORKAREA_BOUNDS_CHANGED
+  WM_EVENT_SYSTEM_UI_AREA_CHANGED,
 };
 
 class ASH_EXPORT WMEvent {

ash/wm/workspace/workspace_layout_manager.cc

@@ -38,10 +38,63 @@
 
 namespace ash {
 
+WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    SettingsBubbleWindowObserver(
+        WorkspaceLayoutManager* workspace_layout_manager)
+    : workspace_layout_manager_(workspace_layout_manager) {}
+
+WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    ~SettingsBubbleWindowObserver() {
+  for (auto* window : windows_)
+    window->RemoveObserver(this);
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::ObserveWindow(
+    aura::Window* window) {
+  if (!windows_.count(window)) {
+    windows_.insert(window);
+    window->AddObserver(this);
+  }
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    OnWindowHierarchyChanged(const HierarchyChangeParams& params) {
+  if (params.new_parent &&
+      params.new_parent !=
+          workspace_layout_manager_->settings_bubble_container_) {
+    StopOberservingWindow(params.target);
+  }
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    OnWindowVisibilityChanged(aura::Window* window, bool visible) {
+  workspace_layout_manager_->NotifySystemUiAreaChanged();
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::OnWindowDestroying(
+    aura::Window* window) {
+  StopOberservingWindow(window);
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    OnWindowBoundsChanged(aura::Window* window,
+                          const gfx::Rect& old_bounds,
+                          const gfx::Rect& new_bounds,
+                          ui::PropertyChangeReason reason) {
+  workspace_layout_manager_->NotifySystemUiAreaChanged();
+}
+
+void WorkspaceLayoutManager::SettingsBubbleWindowObserver::
+    StopOberservingWindow(aura::Window* window) {
+  windows_.erase(window);
+  window->RemoveObserver(this);
+}
+
 WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
     : window_(window),
       root_window_(window->GetRootWindow()),
       root_window_controller_(RootWindowController::ForWindow(root_window_)),
+      settings_bubble_window_observer_(this),
       work_area_in_parent_(
           screen_util::GetDisplayWorkAreaBoundsInParent(window_)),
       is_fullscreen_(wm::GetWindowForFullscreenMode(window) != nullptr) {
@@ -52,11 +105,15 @@ WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
   DCHECK(window->GetProperty(::wm::kSnapChildrenToPixelBoundary));
   backdrop_controller_ = std::make_unique<BackdropController>(window_);
   keyboard::KeyboardController::Get()->AddObserver(this);
+  settings_bubble_container_ = window->GetRootWindow()->GetChildById(
+      kShellWindowId_SettingBubbleContainer);
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
   if (root_window_)
     root_window_->RemoveObserver(this);
+  if (settings_bubble_container_)
+    settings_bubble_container_->RemoveObserver(this);
   for (aura::Window* window : windows_) {
     wm::WindowState* window_state = wm::GetWindowState(window);
     window_state->RemoveObserver(this);
@@ -147,6 +204,14 @@ void WorkspaceLayoutManager::SetChildBounds(aura::Window* child,
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, keyboard::KeyboardControllerObserver implementation:
 
+void WorkspaceLayoutManager::OnKeyboardVisibleBoundsChanged(
+    const gfx::Rect& new_bounds) {
+  auto* keyboard_window =
+      keyboard::KeyboardController::Get()->GetKeyboardWindow();
+  if (keyboard_window && keyboard_window->GetRootWindow() == root_window_)
+    NotifySystemUiAreaChanged();
+}
+
 void WorkspaceLayoutManager::OnKeyboardWorkspaceDisplacingBoundsChanged(
     const gfx::Rect& new_bounds) {
   aura::Window* window = wm::GetActiveWindow();
@@ -186,11 +251,22 @@ void WorkspaceLayoutManager::OnKeyboardWorkspaceDisplacingBoundsChanged(
   }
 }
 
+void WorkspaceLayoutManager::OnStateChanged(
+    keyboard::KeyboardControllerState state) {
+  auto* keyboard_window =
+      keyboard::KeyboardController::Get()->GetKeyboardWindow();
+  if (keyboard_window && keyboard_window->GetRootWindow() == root_window_)
+    NotifySystemUiAreaChanged();
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::WindowObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
+  if (params.new_parent && params.new_parent == settings_bubble_container_)
+    settings_bubble_window_observer_.ObserveWindow(params.target);
+
   if (!wm::GetWindowState(params.target)->IsActive())
     return;
   // If the window is already tracked by the workspace this update would be
@@ -209,6 +285,11 @@ void WorkspaceLayoutManager::OnWindowHierarchyChanged(
   }
 }
 
+void WorkspaceLayoutManager::OnWindowAdded(aura::Window* window) {
+  if (window->parent() == settings_bubble_container_)
+    settings_bubble_window_observer_.ObserveWindow(window);
+}
+
 void WorkspaceLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                      const void* key,
                                                      intptr_t old) {
@@ -236,6 +317,8 @@ void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
     root_window_->RemoveObserver(this);
     root_window_ = nullptr;
   }
+  if (settings_bubble_container_ == window)
+    settings_bubble_container_ = nullptr;
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(
@@ -400,4 +483,11 @@ void WorkspaceLayoutManager::UpdateAlwaysOnTop(aura::Window* window_on_top) {
   }
 }
 
+void WorkspaceLayoutManager::NotifySystemUiAreaChanged() {
+  for (auto* window : windows_) {
+    wm::WMEvent event(wm::WM_EVENT_SYSTEM_UI_AREA_CHANGED);
+    wm::GetWindowState(window)->OnWMEvent(&event);
+  }
+}
+
 }  // namespace ash

ash/wm/workspace/workspace_layout_manager.h

@@ -65,6 +65,7 @@ class ASH_EXPORT WorkspaceLayoutManager
 
   // aura::WindowObserver:
   void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override;
+  void OnWindowAdded(aura::Window* window) override;
   void OnWindowPropertyChanged(aura::Window* window,
                                const void* key,
                                intptr_t old) override;
@@ -85,8 +86,10 @@ class ASH_EXPORT WorkspaceLayoutManager
       aura::Window* lost_active) override;
 
   // keyboard::KeyboardControllerObserver:
+  void OnKeyboardVisibleBoundsChanged(const gfx::Rect& new_bounds) override;
   void OnKeyboardWorkspaceDisplacingBoundsChanged(
       const gfx::Rect& new_bounds) override;
+  void OnStateChanged(keyboard::KeyboardControllerState state) override;
 
   // WindowStateObserver:
   void OnPostWindowStateTypeChange(wm::WindowState* window_state,
@@ -105,6 +108,35 @@ class ASH_EXPORT WorkspaceLayoutManager
   friend class WorkspaceControllerTestApi;
   typedef std::set<aura::Window*> WindowSet;
 
+  // Observes changes in windows in the SettingsBubbleWindowObserver, and
+  // notifies WorkspaceLayoutManager to send out system ui area change events.
+  class SettingsBubbleWindowObserver : public aura::WindowObserver {
+   public:
+    SettingsBubbleWindowObserver(
+        WorkspaceLayoutManager* workspace_layout_manager);
+    ~SettingsBubbleWindowObserver() override;
+
+    void ObserveWindow(aura::Window* window);
+
+    // aura::WindowObserver:
+    void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override;
+    void OnWindowVisibilityChanged(aura::Window* window, bool visible) override;
+    void OnWindowDestroying(aura::Window* window) override;
+    void OnWindowBoundsChanged(aura::Window* window,
+                               const gfx::Rect& old_bounds,
+                               const gfx::Rect& new_bounds,
+                               ui::PropertyChangeReason reason) override;
+
+   private:
+    // WorkspaceLayoutManager has at least as long a lifetime as this class.
+    WorkspaceLayoutManager* workspace_layout_manager_;
+    WindowSet windows_;
+
+    void StopOberservingWindow(aura::Window* window);
+
+    DISALLOW_COPY_AND_ASSIGN(SettingsBubbleWindowObserver);
+  };
+
   // Adjusts the bounds of all managed windows when the display area changes.
   // This happens when the display size, work area insets has changed.
   // If this is called for a display size change (i.e. |event|
@@ -125,9 +157,17 @@ class ASH_EXPORT WorkspaceLayoutManager
   // manager.
   void UpdateAlwaysOnTop(aura::Window* window_on_top);
 
+  // Notifies windows about a change in a system ui area. This could be
+  // the keyboard or any window in the SettingsBubbleContainer. Windows will
+  // only be notified about changes to system ui areas on the display they are
+  // on.
+  void NotifySystemUiAreaChanged();
+
   aura::Window* window_;
   aura::Window* root_window_;
   RootWindowController* root_window_controller_;
+  aura::Window* settings_bubble_container_;
+  SettingsBubbleWindowObserver settings_bubble_window_observer_;
 
   // Set of windows we're listening to.
   WindowSet windows_;

ash/wm/workspace/workspace_layout_manager_unittest.cc

@@ -25,6 +25,7 @@
 #include "ash/shell.h"
 #include "ash/shell_observer.h"
 #include "ash/shell_test_api.h"
+#include "ash/system/unified/unified_system_tray.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/wallpaper/wallpaper_controller_test_api.h"
 #include "ash/window_factory.h"
@@ -39,6 +40,7 @@
 #include "ash/wm/workspace/backdrop_delegate.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ash/wm/workspace_controller_test_api.h"
+#include "base/command_line.h"
 #include "base/run_loop.h"
 #include "chromeos/audio/chromeos_sounds.h"
 #include "ui/aura/client/aura_constants.h"
@@ -59,6 +61,7 @@
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/keyboard/keyboard_controller.h"
+#include "ui/keyboard/keyboard_switches.h"
 #include "ui/keyboard/keyboard_ui.h"
 #include "ui/keyboard/keyboard_util.h"
 #include "ui/keyboard/test/keyboard_test_util.h"
@@ -1828,4 +1831,142 @@ TEST_F(WorkspaceLayoutManagerBackdropTest, BackdropForSplitScreenTest) {
             default_container()->children()[0]->bounds());
 }
 
+namespace {
+
+class TestState : public wm::WindowState::State {
+ public:
+  TestState() = default;
+  ~TestState() override = default;
+
+  // WindowState::State overrides:
+  void OnWMEvent(wm::WindowState* window_state,
+                 const wm::WMEvent* event) override {
+    if (event->type() == wm::WM_EVENT_SYSTEM_UI_AREA_CHANGED)
+      num_system_ui_area_changes_++;
+  }
+  mojom::WindowStateType GetType() const override {
+    return mojom::WindowStateType::NORMAL;
+  }
+  void AttachState(wm::WindowState* window_state,
+                   wm::WindowState::State* previous_state) override {}
+  void DetachState(wm::WindowState* window_state) override {}
+
+  int num_system_ui_area_changes() const { return num_system_ui_area_changes_; }
+
+  void reset_num_system_ui_area_changes() { num_system_ui_area_changes_ = 0; }
+
+ private:
+  int num_system_ui_area_changes_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestState);
+};
+
+}  // namespace
+
+class WorkspaceLayoutManagerSystemUiAreaTest : public AshTestBase {
+ public:
+  WorkspaceLayoutManagerSystemUiAreaTest() = default;
+  ~WorkspaceLayoutManagerSystemUiAreaTest() override = default;
+
+  // AshTestBase:
+  void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        keyboard::switches::kEnableVirtualKeyboard);
+    AshTestBase::SetUp();
+    keyboard::SetTouchKeyboardEnabled(true);
+    Shell::Get()->EnableKeyboard();
+
+    window_ = CreateTestWindowInShellWithBounds(gfx::Rect(0, 0, 100, 100));
+    wm::WindowState* window_state = wm::GetWindowState(window_);
+    test_state_ = new TestState();
+    window_state->SetStateObject(
+        std::unique_ptr<wm::WindowState::State>(test_state_));
+  }
+
+  void TearDown() override {
+    keyboard::SetTouchKeyboardEnabled(false);
+    AshTestBase::TearDown();
+  }
+
+ protected:
+  aura::Window* window() { return window_; }
+  TestState* test_state() { return test_state_; }
+
+ private:
+  aura::Window* window_ = nullptr;
+  TestState* test_state_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerSystemUiAreaTest);
+};
+
+// Expect that showing and hiding the unified system tray triggers a system ui
+// area change event.
+TEST_F(WorkspaceLayoutManagerSystemUiAreaTest,
+       SystemUiAreaChangeOnUnifiedSystemTrayVisibilityChange) {
+  auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
+  EXPECT_FALSE(unified_system_tray->IsBubbleShown());
+  EXPECT_EQ(0, test_state()->num_system_ui_area_changes());
+
+  unified_system_tray->ShowBubble(/*show_by_click=*/false);
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+  test_state()->reset_num_system_ui_area_changes();
+
+  unified_system_tray->CloseBubble();
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+}
+
+// Expect that showing and hiding the keyboard triggers a system ui area
+// change event.
+TEST_F(WorkspaceLayoutManagerSystemUiAreaTest,
+       SystemUiAreaChangeOnVirtualKeyboardVisibilityChange) {
+  auto* keyboard_controller = keyboard::KeyboardController::Get();
+  EXPECT_EQ(0, test_state()->num_system_ui_area_changes());
+
+  keyboard_controller->ShowKeyboard(/*lock=*/true);
+  keyboard_controller->NotifyKeyboardWindowLoaded();
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+  test_state()->reset_num_system_ui_area_changes();
+
+  keyboard_controller->HideKeyboardExplicitlyBySystem();
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+}
+
+// Expect that changing the keyboard bounds triggers a system ui area
+// change event.
+TEST_F(WorkspaceLayoutManagerSystemUiAreaTest,
+       SystemUiAreaChangeOnVirtualKeyboardSizeChange) {
+  auto* keyboard_controller = keyboard::KeyboardController::Get();
+  EXPECT_EQ(0, test_state()->num_system_ui_area_changes());
+
+  keyboard_controller->ShowKeyboard(/*lock=*/true);
+  keyboard_controller->NotifyKeyboardWindowLoaded();
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+  test_state()->reset_num_system_ui_area_changes();
+
+  keyboard_controller->MoveKeyboard(gfx::Rect(0, 0, 100, 100));
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+}
+
+// Expect that changing the keyboard container type triggers a system ui area
+// change event.
+TEST_F(WorkspaceLayoutManagerSystemUiAreaTest,
+       SystemUiAreaChangeOnVirtualKeyboardContainerTypeChange) {
+  auto* keyboard_controller = keyboard::KeyboardController::Get();
+  EXPECT_EQ(0, test_state()->num_system_ui_area_changes());
+
+  keyboard_controller->ShowKeyboard(/*lock=*/true);
+  keyboard_controller->NotifyKeyboardWindowLoaded();
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+  test_state()->reset_num_system_ui_area_changes();
+
+  keyboard_controller->SetContainerType(keyboard::ContainerType::FLOATING,
+                                        base::nullopt, base::DoNothing());
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+  test_state()->reset_num_system_ui_area_changes();
+
+  keyboard_controller->SetContainerType(keyboard::ContainerType::FULL_WIDTH,
+                                        base::nullopt, base::DoNothing());
+  EXPECT_GE(test_state()->num_system_ui_area_changes(), 1);
+}
+
 }  // namespace ash

testing/buildbot/filters/chromeos.single_process_mash.ash_unittests.filter

@@ -11,6 +11,7 @@
 -SystemModalContainerLayoutManagerTest.SystemModalDialogGetPushedFromKeyboard
 -VirtualKeyboardControllerTest.ForceToShowKeyboardWithKeysetWhenKeyboardIsDisabled
 -VirtualKeyboardRootWindowControllerTest.ClickWithActiveModalDialog
+-WorkspaceLayoutManagerSystemUiAreaTest.*
 
 # These tests crash. https://crbug.com/646565
 -LockContentsViewKeyboardUnitTest.AutoLayoutExtraSmallUsersListForKeyboard