Fix "modal isn't modal in multi displays" issue

ash/root_window_controller.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/root_window_controller.h"
 
 #include <queue>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 244 matching lines @@
     }
   }
 
  private:
   aura::Window* root_window_;
   ShelfLayoutManager* shelf_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerDelegateImpl);
 };
 
+bool IsWindowAboveContainer(aura::Window* window,

[James Cook, 2016/06/16 20:31:35]

nit: move up above the class definitions, near the other functions

[oshima, 2016/06/17 00:06:12]

Done.

+                            aura::Window* blocking_container) {
+  std::vector<aura::Window*> target_path;
+  std::vector<aura::Window*> blocking_path;
+
+  while (window) {
+    target_path.push_back(window);
+    window = window->parent();
+  }
+
+  while (blocking_container) {
+    blocking_path.push_back(blocking_container);
+    blocking_container = blocking_container->parent();
+  }
+
+  while (!blocking_path.empty()) {
+    if (target_path.empty())
+      return false;
+
+    aura::Window* target = target_path.back();
+    target_path.pop_back();
+    aura::Window* blocking = blocking_path.back();
+    blocking_path.pop_back();
+
+    // Still on the same path, continue.
+    if (target == blocking)
+      continue;
+
+    // This can happen only if unparented window is passed because
+    // first element must be the same root.
+    if (!target->parent() || !blocking->parent())
+      return false;
+
+    aura::Window* common_parent = target->parent();
+    DCHECK_EQ(common_parent, blocking->parent());

[James Cook, 2016/06/16 20:31:35]

I don't understand how this algorithm works. Maybe you could explain it in a
comment?  In particular, imagine this hierarchy:

Root --> LockScreenContainers --> LockScreenModal --> my_window

blocking starts at LockScreenModal
target starts at my_window

I think we get to here and target->parent() and blocking->parent() are not the
same.  I must be misunderstanding something.

[oshima, 2016/06/17 00:06:12]

Comparison start from the root and that's probably what you missed. I added
comment at the beginning of the while loop.

* If children are same, continue because it's in the same path.
* If different
  - and if target's container is above blocking container, then it's above
blocking path.
  - and if target's container is below blocking container, then it's below
blocking path.

[James Cook, 2016/06/17 16:04:43]

Ah, yes, I missed that the roots were at the end of the array. That makes more
sense now. The comment helps.

+    aura::Window::Windows windows = common_parent->children();
+    auto blocking_iter = std::find(windows.begin(), windows.end(), blocking);
+    // If the target window is above blocking window, the window can handle
+    // events.
+    return std::find(blocking_iter, windows.end(), target) != windows.end();
+  }
+
+  return true;
+}
+
 }  // namespace
 
 void RootWindowController::CreateForPrimaryDisplay(AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host);
   controller->Init(RootWindowController::PRIMARY,
                    Shell::GetInstance()->delegate()->IsFirstRunAfterBoot());
 }
 
 void RootWindowController::CreateForSecondaryDisplay(AshWindowTreeHost* host) {
   RootWindowController* controller = new RootWindowController(host);
@@ skipping 81 matching lines @@
   // Forget with the display ID so that display lookup
   // ends up with invalid display.
   GetRootWindowSettings(root_window)->display_id =
       display::Display::kInvalidDisplayID;
   ash_host_->PrepareForShutdown();
 
   system_background_.reset();
   aura::client::SetScreenPositionClient(root_window, NULL);
 }
 
+bool RootWindowController::CanWindowReceiveEvents(aura::Window* window) {
+  if (GetRootWindow() != window->GetRootWindow())
+    return false;
+
+  // Always allow events to fall through to the virtual keyboard even if
+  // displaying a system modal dialog.
+  if (IsVirtualKeyboardWindow(window))
+    return true;
+
+  aura::Window* blocking_container = nullptr;
+
+  int modal_container_id = 0;
+  if (Shell::GetInstance()->session_state_delegate()->IsUserSessionBlocked()) {
+    blocking_container =
+        GetContainer(kShellWindowId_LockScreenContainersContainer);
+    modal_container_id = kShellWindowId_LockSystemModalContainer;
+  } else {
+    modal_container_id = kShellWindowId_SystemModalContainer;
+  }
+  aura::Window* modal_container = GetContainer(modal_container_id);
+  SystemModalContainerLayoutManager* modal_layout_manager = nullptr;
+  if (modal_container) {

[James Cook, 2016/06/16 20:31:35]

Shouldn't we always have a modal_container?

[oshima, 2016/06/17 00:06:11]

yes, you're right. Done.

+    modal_layout_manager = static_cast<SystemModalContainerLayoutManager*>(
+        modal_container->layout_manager());
+    if (modal_layout_manager->has_modal_background())
+      blocking_container = modal_container;
+    else
+      modal_layout_manager = nullptr;

[James Cook, 2016/06/16 20:31:35]

do you need this else clause?

[oshima, 2016/06/17 00:06:12]

Changed to modal_container for line 450. The condition was a bit different (was
using modal_layout_manager), and I forgot to update this.

+  }
+
+  // In normal session.
+  if (blocking_container == nullptr)
+    return true;
+
+  if (!IsWindowAboveContainer(window, blocking_container))
+    return false;
+
+  // If the window is in the target modal container, only allow the top most
+  // one.
+  if (modal_container && modal_container->Contains(window))
+    return modal_layout_manager->IsActiveModalWindows(window);
+
+  return true;
+}
+
 SystemModalContainerLayoutManager*
 RootWindowController::GetSystemModalLayoutManager(aura::Window* window) {
   aura::Window* modal_container = NULL;
   if (window) {
     aura::Window* window_container = WmWindowAura::GetAuraWindow(
         wm::GetContainerForWindow(WmWindowAura::Get(window)));
     if (window_container &&
         window_container->id() >= kShellWindowId_LockScreenContainer) {
       modal_container = GetContainer(kShellWindowId_LockSystemModalContainer);
     } else {
@@ skipping 510 matching lines @@
     aura::Window* primary_root_window = Shell::GetInstance()
                                             ->window_tree_host_manager()
                                             ->GetPrimaryRootWindow();
     return GetRootWindowSettings(primary_root_window)->controller;
   }
 
   return GetRootWindowSettings(root_window)->controller;
 }
 
 }  // namespace ash