Move mus::InputEventHandler implementation and tests from PlatformWindowMus to NativeWidgetMus

ui/views/mus/native_widget_mus.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 "ui/views/mus/native_widget_mus.h"
 
+#include "base/callback.h"
 #include "base/macros.h"
+#include "base/message_loop/message_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/interfaces/cursor.mojom.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "components/mus/public/interfaces/window_manager_constants.mojom.h"
+#include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
+#include "ui/events/event.h"
 #include "ui/gfx/canvas.h"
 #include "ui/native_theme/native_theme_aura.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/views/mus/platform_window_mus.h"
 #include "ui/views/mus/surface_context_factory.h"
 #include "ui/views/mus/window_manager_constants_converters.h"
 #include "ui/views/mus/window_manager_frame_values.h"
 #include "ui/views/mus/window_tree_host_mus.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/window/custom_frame_view.h"
 #include "ui/wm/core/base_focus_rules.h"
 #include "ui/wm/core/capture_controller.h"
 #include "ui/wm/core/cursor_manager.h"
 #include "ui/wm/core/default_screen_position_client.h"
 #include "ui/wm/core/focus_controller.h"
 #include "ui/wm/core/native_cursor_manager.h"
 
 DECLARE_WINDOW_PROPERTY_TYPE(mus::Window*);
 
+using mus::mojom::EventResult;
+
 namespace views {
 namespace {
 
 DEFINE_WINDOW_PROPERTY_KEY(mus::Window*, kMusWindow, nullptr);
 
 MUS_DEFINE_WINDOW_PROPERTY_KEY(NativeWidgetMus*, kNativeWidgetMusKey, nullptr);
 
 // This ensures that only the top-level aura Window can be activated.
 class FocusRulesImpl : public wm::BaseFocusRules {
  public:
@@ skipping 234 matching lines @@
 // TODO(jamescook): Support other scale factors.
 SkBitmap AppIconFromDelegate(WidgetDelegate* delegate) {
   if (!delegate)
     return SkBitmap();
   gfx::ImageSkia app_icon = delegate->GetWindowAppIcon();
   if (app_icon.isNull())
     return SkBitmap();
   return app_icon.GetRepresentation(1.f).sk_bitmap();
 }
 
+// Handles acknowledgement of an input event, either immediately when a nested
+// message loop starts, or upon destruction.
+class EventAckHandler : public base::MessageLoop::NestingObserver {
+ public:
+  explicit EventAckHandler(
+      std::unique_ptr<base::Callback<void(EventResult)>> ack_callback)
+      : ack_callback_(std::move(ack_callback)) {
+    DCHECK(ack_callback_);
+    base::MessageLoop::current()->AddNestingObserver(this);
+  }
+
+  ~EventAckHandler() override {
+    base::MessageLoop::current()->RemoveNestingObserver(this);
+    if (ack_callback_) {
+      ack_callback_->Run(handled_ ? EventResult::HANDLED
+                                  : EventResult::UNHANDLED);
+    }
+  }
+
+  void set_handled(bool handled) { handled_ = handled; }
+
+  // base::MessageLoop::NestingObserver:
+  void OnBeginNestedMessageLoop() override {
+    // Acknowledge the event immediately if a nested message loop starts.
+    // Otherwise we appear unresponsive for the life of the nested message loop.
+    if (ack_callback_) {
+      ack_callback_->Run(EventResult::HANDLED);
+      ack_callback_.reset();
+    }
+  }
+
+ private:
+  std::unique_ptr<base::Callback<void(EventResult)>> ack_callback_;
+  bool handled_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
+};
+
 }  // namespace
 
 class NativeWidgetMus::MusWindowObserver : public mus::WindowObserver {
  public:
   explicit MusWindowObserver(NativeWidgetMus* native_widget_mus)
       : native_widget_mus_(native_widget_mus),
         show_state_(mus::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
@@ skipping 902 matching lines @@
 }
 
 void NativeWidgetMus::OnGestureEvent(ui::GestureEvent* event) {
   native_widget_delegate_->OnGestureEvent(event);
 }
 
 void NativeWidgetMus::OnHostCloseRequested(const aura::WindowTreeHost* host) {
   GetWidget()->Close();
 }
 
+void NativeWidgetMus::OnWindowInputEvent(
+    mus::Window* view,
+    const ui::Event& event_in,
+    std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
+  // Take ownership of the callback, indicating that we will handle it.
+  EventAckHandler ack_handler(std::move(*ack_callback));
+
+  std::unique_ptr<ui::Event> event = ui::Event::Clone(event_in);
+  // TODO(markdittmer): This should be this->OnEvent(event.get()), but that
+  // can't happen until IME is refactored out of in WindowTreeHostMus.
+  platform_window_delegate()->DispatchEvent(event.get());
+  // NOTE: |this| may be deleted.
+
+  ack_handler.set_handled(event->handled());
+  // |ack_handler| acks the event on destruction if necessary.
+}
+
 void NativeWidgetMus::OnMusWindowVisibilityChanging(mus::Window* window) {
   native_widget_delegate_->OnNativeWidgetVisibilityChanging(!window->visible());
 }
 
 void NativeWidgetMus::OnMusWindowVisibilityChanged(mus::Window* window) {
   if (window->visible()) {
     window_tree_host_->Show();
     window_->SetVisible(true);
     GetNativeWindow()->Show();
   } else {
     window_tree_host_->Hide();
     window_->SetVisible(false);
     GetNativeWindow()->Hide();
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(window->visible());
 }
 
 }  // namespace views