First cut at supporting activation in the window manager

mojo/services/window_manager/window_manager_app.cc

 // Copyright 2014 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 "mojo/services/window_manager/window_manager_app.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "mojo/aura/aura_init.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/focus_controller.h"
-#include "ui/wm/core/focus_rules.h"
 #include "ui/wm/public/activation_client.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(mojo::View*);
 
 namespace mojo {
 
 // The aura::Windows we use to track Views don't render, so we don't actually
 // need to supply a fully functional WindowDelegate. We do need to provide _a_
 // delegate however, otherwise the event dispatcher won't dispatch events to
 // these windows. (The aura WindowTargeter won't allow a delegate-less window
@@ skipping 33 matching lines @@
 };
 
 namespace {
 
 DEFINE_WINDOW_PROPERTY_KEY(View*, kViewKey, NULL);
 
 Id GetIdForWindow(aura::Window* window) {
   return window ? WindowManagerApp::GetViewForWindow(window)->id() : 0;
 }
 
-class WMFocusRules : public wm::FocusRules {
- public:
-  WMFocusRules() {}
-  virtual ~WMFocusRules() {}
-
- private:
-  // Overridden from wm::FocusRules:
-  virtual bool IsToplevelWindow(aura::Window* window) const MOJO_OVERRIDE {
-    return true;
-  }
-  virtual bool CanActivateWindow(aura::Window* window) const MOJO_OVERRIDE {
-    return true;
-  }
-  virtual bool CanFocusWindow(aura::Window* window) const MOJO_OVERRIDE {
-    return true;
-  }
-  virtual aura::Window* GetToplevelWindow(
-      aura::Window* window) const MOJO_OVERRIDE {
-    return window;
-  }
-  virtual aura::Window* GetActivatableWindow(
-      aura::Window* window) const MOJO_OVERRIDE {
-    return window;
-  }
-  virtual aura::Window* GetFocusableWindow(
-      aura::Window* window) const MOJO_OVERRIDE {
-    return window;
-  }
-  virtual aura::Window* GetNextActivatableWindow(
-      aura::Window* ignore) const MOJO_OVERRIDE {
-    return NULL;
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(WMFocusRules);
-};
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, public:
 
 WindowManagerApp::WindowManagerApp(
     ViewManagerDelegate* view_manager_delegate,
     WindowManagerDelegate* window_manager_delegate)
     : window_manager_service_factory_(this),
       wrapped_view_manager_delegate_(view_manager_delegate),
       wrapped_window_manager_delegate_(window_manager_delegate),
       view_manager_(NULL),
       root_(NULL),
       dummy_delegate_(new DummyDelegate) {
 }
 
 WindowManagerApp::~WindowManagerApp() {}
 
 // static
 View* WindowManagerApp::GetViewForWindow(aura::Window* window) {
   return window->GetProperty(kViewKey);
 }
 
+aura::Window* WindowManagerApp::GetWindowForViewId(Id view) {
+  ViewIdToWindowMap::const_iterator it = view_id_to_window_map_.find(view);
+  return it != view_id_to_window_map_.end() ? it->second : NULL;
+}
+
 void WindowManagerApp::AddConnection(WindowManagerServiceImpl* connection) {
   DCHECK(connections_.find(connection) == connections_.end());
   connections_.insert(connection);
 }
 
 void WindowManagerApp::RemoveConnection(WindowManagerServiceImpl* connection) {
   DCHECK(connections_.find(connection) != connections_.end());
   connections_.erase(connection);
 }
 
@@ skipping 12 matching lines @@
 void WindowManagerApp::ActivateWindow(Id view) {
   aura::Window* window = GetWindowForViewId(view);
   DCHECK(window);
   activation_client_->ActivateWindow(window);
 }
 
 bool WindowManagerApp::IsReady() const {
   return view_manager_ && root_;
 }
 
+void WindowManagerApp::InitFocus(wm::FocusRules* rules) {
+  wm::FocusController* focus_controller = new wm::FocusController(rules);
+  activation_client_ = focus_controller;
+  focus_client_.reset(focus_controller);
+  aura::client::SetFocusClient(window_tree_host_->window(), focus_controller);
+  aura::client::SetActivationClient(window_tree_host_->window(),
+                                    focus_controller);
+
+  focus_client_->AddObserver(this);
+  activation_client_->AddObserver(this);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, ApplicationDelegate implementation:
 
 void WindowManagerApp::Initialize(ApplicationImpl* impl) {
   aura_init_.reset(new AuraInit);
   view_manager_client_factory_.reset(
       new ViewManagerClientFactory(impl->shell(), this));
 }
 
 bool WindowManagerApp::ConfigureIncomingConnection(
@@ skipping 16 matching lines @@
   root_ = root;
 
   window_tree_host_.reset(new WindowTreeHostMojo(root_, this));
   window_tree_host_->window()->SetBounds(root->bounds());
   window_tree_host_->window()->Show();
 
   RegisterSubtree(root_, window_tree_host_->window());
 
   capture_client_.reset(
       new wm::ScopedCaptureClient(window_tree_host_->window()));
-  wm::FocusController* focus_controller =
-      new wm::FocusController(new WMFocusRules);
-  activation_client_ = focus_controller;
-  focus_client_.reset(focus_controller);
-  aura::client::SetFocusClient(window_tree_host_->window(), focus_controller);
-
-  focus_client_->AddObserver(this);
-  activation_client_->AddObserver(this);
 
   if (wrapped_view_manager_delegate_) {
     wrapped_view_manager_delegate_->OnEmbed(
         view_manager, root, exported_services, imported_services.Pass());
   }
 
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyReady();
   }
@@ skipping 100 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, aura::client::ActivationChangeObserver implementation:
 
 void WindowManagerApp::OnWindowActivated(aura::Window* gained_active,
                                          aura::Window* lost_active) {
   for (Connections::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     (*it)->NotifyWindowActivated(GetIdForWindow(gained_active),
                                  GetIdForWindow(lost_active));
   }
+  if (gained_active) {
+    View* view = GetViewForWindow(gained_active);
+    view->MoveToFront();
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WindowManagerApp, private:
 
-aura::Window* WindowManagerApp::GetWindowForViewId(Id view) const {
-  ViewIdToWindowMap::const_iterator it = view_id_to_window_map_.find(view);
-  return it != view_id_to_window_map_.end() ? it->second : NULL;
-}
-
 void WindowManagerApp::RegisterSubtree(View* view, aura::Window* parent) {
   view->AddObserver(this);
   DCHECK(view_id_to_window_map_.find(view->id()) ==
          view_id_to_window_map_.end());
   aura::Window* window = new aura::Window(dummy_delegate_.get());
   window->set_id(view->id());
   window->SetProperty(kViewKey, view);
   // All events pass through the root during dispatch, so we only need a handler
   // installed there.
   if (view == root_)
@@ skipping 12 matching lines @@
   ViewIdToWindowMap::iterator it = view_id_to_window_map_.find(view->id());
   DCHECK(it != view_id_to_window_map_.end());
   scoped_ptr<aura::Window> window(it->second);
   view_id_to_window_map_.erase(it);
   View::Children::const_iterator child = view->children().begin();
   for (; child != view->children().end(); ++child)
     UnregisterSubtree(*child);
 }
 
 }  // namespace mojo