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 12 matching lines @@
     mojo::ApplicationImpl* app_impl,
     const scoped_refptr<GpuState>& gpu_state,
     const scoped_refptr<SurfacesState>& surfaces_state,
     mojom::WindowManagerPtr window_manager)
     : delegate_(nullptr),
       connection_manager_(connection_manager),
       client_(client.Pass()),
       event_dispatcher_(this),
       display_manager_(
           DisplayManager::Create(app_impl, gpu_state, surfaces_state)),
-      focus_controller_(new FocusController),
+      focus_controller_(new FocusController(this)),
       window_manager_(window_manager.Pass()) {
   focus_controller_->AddObserver(this);
   display_manager_->Init(this);
   if (client_) {
     client_.set_connection_error_handler(base::Bind(
         &WindowTreeHostImpl::OnClientClosed, base::Unretained(this)));
   }
 }
 
 WindowTreeHostImpl::~WindowTreeHostImpl() {
@@ skipping 86 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::AddActivationParent(uint32_t window_id) {
+  ServerWindow* window =
+      connection_manager_->GetWindow(WindowIdFromTransportId(window_id));
+  if (window)
+    activation_parents_.insert(window->id());
+}
+
+void WindowTreeHostImpl::RemoveActivationParent(uint32_t window_id) {
+  ServerWindow* window =
+      connection_manager_->GetWindow(WindowIdFromTransportId(window_id));
+  if (window)
+    activation_parents_.erase(window->id());
+}
+
 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 33 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);
+  }
+}
+
 void WindowTreeHostImpl::OnFocusChanged(
     FocusControllerChangeSource change_source,
     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
@@ skipping 84 matching lines @@
                                            base::Bind(&base::DoNothing));
 }
 
 void WindowTreeHostImpl::OnWindowDestroyed(ServerWindow* window) {
   windows_needing_frame_destruction_.erase(window);
   window->RemoveObserver(this);
 }
 
 }  // namespace ws
 }  // namespace mus