exo: WMHelperMus: Hook up event handlers for mus+ash

components/exo/wm_helper_mus.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 "components/exo/wm_helper_mus.h"
 
 #include "ash/common/display/display_info.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "ui/aura/client/focus_client.h"
+#include "ui/aura/env.h"
+#include "ui/aura/window.h"
 #include "ui/views/mus/native_widget_mus.h"
 #include "ui/views/mus/window_manager_connection.h"
 #include "ui/views/widget/widget.h"
 
 namespace exo {
 namespace {
 
 aura::Window* GetToplevelAuraWindow(ui::Window* window) {
   if (!window)
     return nullptr;
   // We never create child ui::Window, so window->parent() should be null.
   DCHECK(!window->parent());
   auto* widget = views::NativeWidgetMus::GetWidgetForWindow(window);
   if (!widget)
     return nullptr;
   return widget->GetNativeWindow();
 }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// WMHelperMus::EventForwarder:
+
+class WMHelperMus::EventForwarder : public ui::EventHandler {
+ public:
+  EventForwarder(WMHelperMus* helper, bool is_post)

[reveman, 2016/08/22 13:41:42]

Can we pass a ui::EventHandlerList reference to this ctor and avoid the callback
into the helper class?

[Peng, 2016/08/22 14:32:40]

Done.

+      : helper_(helper), is_post_(is_post) {}
+  ~EventForwarder() override {}
+
+  // Overriden from ui::EventHandler:
+  void OnEvent(ui::Event* event) override {
+    helper_->ForwardEvent(event, is_post_);
+  }
+
+ private:
+  WMHelperMus* helper_;
+  const bool is_post_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventForwarder);
+};
+
+////////////////////////////////////////////////////////////////////////////////
 // WMHelperMus, public:
 
 WMHelperMus::WMHelperMus()
-    : active_window_(GetActiveWindow()), focused_window_(GetFocusedWindow()) {
+    : pre_target_event_forwarder_(new EventForwarder(this, false)),
+      post_target_event_forwarder_(new EventForwarder(this, true)),
+      active_window_(GetActiveWindow()),
+      focused_window_(GetFocusedWindow()) {
   views::WindowManagerConnection::Get()->window_tree_client()->AddObserver(
       this);
+  aura::Env::GetInstance()->AddObserver(this);
 }
 
 WMHelperMus::~WMHelperMus() {
+  auto* env = aura::Env::GetInstance();
+  if (env)

[reveman, 2016/08/22 13:41:42]

Why this conditional necessary? Would be nice if we could instead DCHECK and
require that this instance is destroyed before aura env..

[Peng, 2016/08/22 14:32:40]

Done.

+    env->RemoveObserver(this);
   auto* connection = views::WindowManagerConnection::Get();
   if (connection)
     connection->window_tree_client()->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WMHelperMus, private:
 
 const ash::DisplayInfo WMHelperMus::GetDisplayInfo(int64_t display_id) const {
-  NOTIMPLEMENTED();
-  return ash::DisplayInfo();
+  // TODO(penghuang): Return real display info when it is supported in mus.
+  return ash::DisplayInfo(display_id, "", false);
 }
 
 aura::Window* WMHelperMus::GetContainer(int container_id) {
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 aura::Window* WMHelperMus::GetActiveWindow() const {
   ui::Window* window = views::WindowManagerConnection::Get()
                            ->window_tree_client()
                            ->GetFocusedWindow();
   return GetToplevelAuraWindow(window);
 }
 
 aura::Window* WMHelperMus::GetFocusedWindow() const {
   auto* active_window = GetActiveWindow();
   if (!active_window)
     return nullptr;
   auto* focus_client = aura::client::GetFocusClient(active_window);
   return focus_client->GetFocusedWindow();
 }
 
 ui::CursorSetType WMHelperMus::GetCursorSet() const {
   NOTIMPLEMENTED();
   return ui::CursorSetType::CURSOR_SET_NORMAL;
 }
 
 void WMHelperMus::AddPreTargetHandler(ui::EventHandler* handler) {
-  NOTIMPLEMENTED();
+  pre_target_list_.push_back(handler);
 }
 
 void WMHelperMus::PrependPreTargetHandler(ui::EventHandler* handler) {
-  NOTIMPLEMENTED();
+  pre_target_list_.insert(pre_target_list_.begin(), handler);
 }
 
 void WMHelperMus::RemovePreTargetHandler(ui::EventHandler* handler) {
-  NOTIMPLEMENTED();
+  auto it =
+      std::find(pre_target_list_.begin(), pre_target_list_.end(), handler);
+  if (it != pre_target_list_.end())
+    pre_target_list_.erase(it);
 }
 
 void WMHelperMus::AddPostTargetHandler(ui::EventHandler* handler) {
-  NOTIMPLEMENTED();
+  post_target_list_.push_back(handler);
 }
 
 void WMHelperMus::RemovePostTargetHandler(ui::EventHandler* handler) {
-  NOTIMPLEMENTED();
+  auto it =
+      std::find(post_target_list_.begin(), post_target_list_.end(), handler);
+  if (it != post_target_list_.end())
+    post_target_list_.erase(it);
 }
 
 bool WMHelperMus::IsMaximizeModeWindowManagerEnabled() const {
   NOTIMPLEMENTED();
   return false;
 }
 
+void WMHelperMus::OnHostInitialized(aura::WindowTreeHost* host) {
+  auto* root_window = host->window();
+  root_window->AddPreTargetHandler(pre_target_event_forwarder_.get());
+  root_window->AddPostTargetHandler(post_target_event_forwarder_.get());
+}
+
 void WMHelperMus::OnWindowTreeFocusChanged(ui::Window* gained_focus,
                                            ui::Window* lost_focus) {
   aura::Window* gained_active = GetToplevelAuraWindow(gained_focus);
   aura::Window* lost_active = GetToplevelAuraWindow(lost_focus);
 
   OnWindowFocused(nullptr, focused_window_);
 
   // Because NativeWidgetMus uses separate FocusClient for every toplevel
   // window, we have to stop observering the FocusClient of the |lost_active|
   // and start observering the FocusClient of the |gained_active|.
@@ skipping 13 matching lines @@
 }
 
 void WMHelperMus::OnWindowFocused(aura::Window* gained_focus,
                                   aura::Window* lost_focus) {
   if (focused_window_ != gained_focus) {
     focused_window_ = gained_focus;
     NotifyWindowFocused(gained_focus, lost_focus);
   }
 }
 
+void WMHelperMus::ForwardEvent(ui::Event* event, bool is_post) {
+  auto it = is_post ? post_target_list_.begin() : pre_target_list_.begin();
+  auto end = is_post ? post_target_list_.end() : pre_target_list_.end();
+  for (; it != end; ++it) {
+    if (!is_post && event->stopped_propagation())

[reveman, 2016/08/22 13:41:42]

why is stopped_propagation() only respected in the pre target handler but not
the post target handler?

[Peng, 2016/08/22 14:32:40]

I thought we should always dispatch event to post event handlers. But after
checking the code again, I find out I was wrong.

Done.

+      break;
+    (*it)->OnEvent(event);
+  }
+}
+
 }  // namespace exo