Hook up proper FocusController for simple_wm.

mash/simple_wm/simple_wm.cc

 // Copyright 2016 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 "mash/simple_wm/simple_wm.h"
 
 #include "base/observer_list.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mash/simple_wm/move_event_handler.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/display/screen_base.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/mojo/geometry.mojom.h"
 #include "ui/views/controls/button/md_text_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/mus/aura_init.h"
 #include "ui/views/mus/mus_client.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
-#include "ui/wm/core/default_activation_client.h"
+#include "ui/wm/core/focus_controller.h"
 
 namespace simple_wm {
 
 namespace {
 
 const int kNonClientTopHeight = 24;
 const int kNonClientSize = 5;
 const int kNonClientMaximizedTopOverlap = 4;
 
 }  // namespace
@@ skipping 301 matching lines @@
     window_list_view_->GetWidget()->SetBounds(window_list_view_bounds);
   }
 
   aura::Window* display_root_;
   aura::Window* window_root_;
   SimpleWM::WindowListView* window_list_view_;
 
   DISALLOW_COPY_AND_ASSIGN(DisplayLayoutManager);
 };
 
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, public:
+
 SimpleWM::SimpleWM() {}
 
 SimpleWM::~SimpleWM() {
   // WindowTreeHost uses state from WindowTreeClient, so destroy it first.
   window_tree_host_.reset();
 
   // WindowTreeClient destruction may callback to us.
   window_tree_client_.reset();
 
   gpu_.reset();
 
   display::Screen::SetScreenInstance(nullptr);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, service_manager::Service implementation:
+
 void SimpleWM::OnStart() {
   CHECK(!started_);
   started_ = true;
   screen_ = base::MakeUnique<display::ScreenBase>();
   display::Screen::SetScreenInstance(screen_.get());
   aura_init_ = base::MakeUnique<views::AuraInit>(
       context()->connector(), context()->identity(), "views_mus_resources.pak",
       std::string(), nullptr, views::AuraInit::Mode::AURA_MUS_WINDOW_MANAGER);
   gpu_ = ui::Gpu::Create(context()->connector(), nullptr);
   compositor_context_factory_ =
       base::MakeUnique<aura::MusContextFactory>(gpu_.get());
   aura::Env::GetInstance()->set_context_factory(
       compositor_context_factory_.get());
   window_tree_client_ = base::MakeUnique<aura::WindowTreeClient>(
       context()->connector(), this, this);
   aura::Env::GetInstance()->SetWindowTreeClient(window_tree_client_.get());
   window_tree_client_->ConnectAsWindowManager();
 }
 
 bool SimpleWM::OnConnect(
     const service_manager::ServiceInfo& remote_info,
     service_manager::InterfaceRegistry* registry) {
   return true;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, aura::WindowTreeClientDelegate implementation:
+
 void SimpleWM::OnEmbed(
     std::unique_ptr<aura::WindowTreeHostMus> window_tree_host) {
   // WindowTreeClients configured as the window manager should never get
   // OnEmbed().
   NOTREACHED();
 }
 
 void SimpleWM::OnLostConnection(aura::WindowTreeClient* client) {
   window_tree_host_.reset();
   window_tree_client_.reset();
@@ skipping 11 matching lines @@
 }
 
 aura::client::CaptureClient* SimpleWM::GetCaptureClient() {
   return wm_state_.capture_controller();
 }
 
 aura::PropertyConverter* SimpleWM::GetPropertyConverter() {
   return &property_converter_;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, aura::WindowManagerDelegate implementation:
+
 void SimpleWM::SetWindowManagerClient(
     aura::WindowManagerClient* client) {
   window_manager_client_ = client;
 }
 
 bool SimpleWM::OnWmSetBounds(aura::Window* window, gfx::Rect* bounds) {
   FrameView* frame_view = GetFrameViewForClientWindow(window);
   frame_view->GetWidget()->SetBounds(*bounds);
   return false;
 }
@@ skipping 84 matching lines @@
 
   DCHECK(window_manager_client_);
   window_manager_client_->AddActivationParent(window_root_);
   ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ui::mojom::FrameDecorationValues::New();
   frame_decoration_values->normal_client_area_insets.Set(
       kNonClientTopHeight, kNonClientSize, kNonClientSize, kNonClientSize);
   frame_decoration_values->max_title_bar_button_width = 0;
   window_manager_client_->SetFrameDecorationValues(
       std::move(frame_decoration_values));
-  new wm::DefaultActivationClient(display_root_);
-  aura::client::SetFocusClient(display_root_, &focus_client_);
+  focus_controller_ = base::MakeUnique<wm::FocusController>(this);
+  aura::client::SetFocusClient(display_root_, focus_controller_.get());
+  aura::client::SetActivationClient(display_root_, focus_controller_.get());
+  display_root_->AddPreTargetHandler(focus_controller_.get());
 }
 
 void SimpleWM::OnWmDisplayRemoved(
     aura::WindowTreeHostMus* window_tree_host) {
   DCHECK_EQ(window_tree_host, window_tree_host_.get());
   window_root_ = nullptr;
   window_tree_host_.reset();
 }
 
 void SimpleWM::OnWmDisplayModified(const display::Display& display) {}
 
 void SimpleWM::OnWmPerformMoveLoop(
     aura::Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& on_done) {
   // Don't care.
 }
 
 void SimpleWM::OnWmCancelMoveLoop(aura::Window* window) {}
 
 void SimpleWM::OnWmSetClientArea(
     aura::Window* window,
     const gfx::Insets& insets,
     const std::vector<gfx::Rect>& additional_client_areas) {}
 
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, wm::BaseFocusRules implementation:
+
+bool SimpleWM::SupportsChildActivation(aura::Window* window) const {
+  return window == window_root_;

[sky, 2017/01/03 23:52:34]

Shouldn't you only return true if window is in client_window_to_frame_view_?

[Ben Goodger (Google), 2017/01/03 23:54:40]

The window passed to this function is the parent of the window being activated,
which is the outer (frame view) window.

[sky, 2017/01/04 00:09:58]

Ah, got it.

+}
+
+bool SimpleWM::IsWindowConsideredVisibleForActivation(
+    aura::Window* window) const {
+  if (window->IsVisible())
+    return true;
+
+  ui::WindowShowState show_state =
+    window->GetProperty(aura::client::kShowStateKey);
+  if (show_state == ui::SHOW_STATE_MINIMIZED)
+    return true;
+
+  return window->TargetVisibility();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// SimpleWM, private:
+
 SimpleWM::FrameView* SimpleWM::GetFrameViewForClientWindow(
     aura::Window* client_window) {
   auto it = client_window_to_frame_view_.find(client_window);
   return it != client_window_to_frame_view_.end() ? it->second : nullptr;
 }
 
 void SimpleWM::OnWindowListViewItemActivated(aura::Window* window) {
   window->Show();
   aura::client::ActivationClient* activation_client =
       aura::client::GetActivationClient(window->GetRootWindow());
   activation_client->ActivateWindow(window);
 }
 
 }  // namespace simple_wm