mus: Allow the WM to specify the windows that can have active children.

components/mus/ws/window_tree_host_impl.cc

 // Copyright 2015 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 "components/mus/ws/window_tree_host_impl.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display_manager.h"
@@ skipping 72 matching lines @@
   return display_manager_->GetViewportMetrics();
 }
 
 void WindowTreeHostImpl::SetFocusedWindow(ServerWindow* new_focused_window) {
   ServerWindow* old_focused_window = focus_controller_->GetFocusedWindow();
   if (old_focused_window == new_focused_window)
     return;
   DCHECK(root_window()->Contains(new_focused_window));
   focus_controller_->SetFocusedWindow(new_focused_window);
   // TODO(beng): have the FocusController notify us via FocusControllerDelegate.
+  // It is possible that FocusController set the focus to a different window. So
+  // take that into account before calling into OnFocusChanged().
+  new_focused_window = focus_controller_->GetFocusedWindow();
+  if (new_focused_window == old_focused_window)
+    return;
   OnFocusChanged(old_focused_window, new_focused_window);
 }
 
 ServerWindow* WindowTreeHostImpl::GetFocusedWindow() {
   return focus_controller_->GetFocusedWindow();
 }
 
 void WindowTreeHostImpl::DestroyFocusController() {
   focus_controller_.reset();
 }
@@ skipping 23 matching lines @@
 
 void WindowTreeHostImpl::AddAccelerator(uint32_t id,
                                         mojom::EventMatcherPtr event_matcher) {
   event_dispatcher_.AddAccelerator(id, event_matcher.Pass());
 }
 
 void WindowTreeHostImpl::RemoveAccelerator(uint32_t id) {
   event_dispatcher_.RemoveAccelerator(id);
 }
 
+void WindowTreeHostImpl::SetActivationParent(uint32_t window_id, bool enable) {
+  ServerWindow* window =
+      connection_manager_->GetWindow(WindowIdFromTransportId(window_id));
+  bool wm_misbehaving = false;

[Ben Goodger (Google), 2015/11/19 07:26:24]

what's this for?

[sadrul, 2015/11/19 19:33:34]

I would normally do a DCHECK(window) here, but a misbehaving WM could then bring
down mus. I was contemplating having some mechanism to signal a misbehaving WM,
or shut it down + restart it if it is misbehaving too often. But we can look at
that in the future. Removed the relevant code.

+  if (window) {
+    if (enable) {
+      auto it = activation_parents_.insert(window->id());
+      if (!it.second)
+        wm_misbehaving = true;
+    } else {
+      size_t count = activation_parents_.erase(window->id());
+      if (!count)
+        wm_misbehaving = true;
+    }
+  } else {
+    wm_misbehaving = true;
+  }
+
+  if (wm_misbehaving) {
+    // TODO: kill the WM?
+    NOTREACHED();
+  }
+}
+
 void WindowTreeHostImpl::OnClientClosed() {
   // |display_manager_.reset()| destroys the display-manager first, and then
   // sets |display_manager_| to nullptr. However, destroying |display_manager_|
   // can destroy the corresponding WindowTreeHostConnection, and |this|. So
   // setting it to nullptr afterwards in reset() ends up writing on free'd
   // memory. So transfer over to a local scoped_ptr<> before destroying it.
   scoped_ptr<DisplayManager> temp = display_manager_.Pass();
 }
 
 ServerWindow* WindowTreeHostImpl::GetRootWindow() {
@@ skipping 32 matching lines @@
 
 void WindowTreeHostImpl::OnCompositorFrameDrawn() {
   std::set<ServerWindow*> windows;
   windows.swap(windows_needing_frame_destruction_);
   for (ServerWindow* window : windows) {
     window->RemoveObserver(this);
     window->DestroySurfacesScheduledForDestruction();
   }
 }
 
+bool WindowTreeHostImpl::CanHaveActiveChildren(ServerWindow* window) const {
+  return window && activation_parents_.count(window->id()) > 0;
+}
+
+void WindowTreeHostImpl::OnActivationChanged(ServerWindow* old_active_window,
+                                             ServerWindow* new_active_window) {
+  DCHECK_NE(new_active_window, old_active_window);
+  if (new_active_window && new_active_window->parent()) {
+    // Raise the new active window.
+    // TODO(sad): Let the WM dictate whether to raise the window or not?
+    new_active_window->parent()->StackChildAtTop(new_active_window);

[Ben Goodger (Google), 2015/11/19 07:26:25]

does this account for transients?

[sadrul, 2015/11/19 19:33:34]

StackChildAtTop() etc. account for transients, yep. (turns out transiency isn't
quite set-up correctly yet from views. Fix up in
https://codereview.chromium.org/1462123002/)

+  }
+}
+
 void WindowTreeHostImpl::OnFocusChanged(ServerWindow* old_focused_window,
                                         ServerWindow* new_focused_window) {
   // There are up to four connections that need to be notified:
   // . the connection containing |old_focused_window|.
   // . the connection with |old_focused_window| as its root.
   // . the connection containing |new_focused_window|.
   // . the connection with |new_focused_window| as its root.
   // Some of these connections may be the same. The following takes care to
   // notify each only once.
   WindowTreeImpl* owning_connection_old = nullptr;
@@ skipping 82 matching lines @@
                                            base::Bind(&base::DoNothing));
 }
 
 void WindowTreeHostImpl::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
 }  // namespace ws
 }  // namespace mus