StructTraits to map mus::mojom::Event to unique_ptr<ui::Event>

components/mus/public/cpp/lib/window_tree_client.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 "components/mus/public/cpp/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 855 matching lines @@
   if (!window)
     return;
 
   InFlightPropertyChange new_change(window, name, new_data);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetSharedProperty(name, std::move(new_data));
 }
 
-void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
-                                              Id window_id,
-                                              mojom::EventPtr event,
-                                              uint32_t event_observer_id) {
-  std::unique_ptr<ui::Event> ui_event = event.To<std::unique_ptr<ui::Event>>();
+void WindowTreeClient::OnWindowInputEvent(
+    uint32_t event_id,
+    Id window_id,
+    const std::unique_ptr<ui::Event>& event,
+    uint32_t event_observer_id) {
+  DCHECK(event);
   Window* window = GetWindowByServerId(window_id);  // May be null.
 
   // Non-zero event_observer_id means it matched an event observer on the
   // server.
   if (event_observer_id != 0 && has_event_observer_ &&
       event_observer_id == event_observer_id_)
-    delegate_->OnEventObserved(*ui_event, window);
+    delegate_->OnEventObserved(*event.get(), window);
 
   if (!window || !window->input_event_handler_) {
     tree_->OnWindowInputEventAck(event_id, mojom::EventResult::UNHANDLED);
     return;
   }
 
   std::unique_ptr<base::Callback<void(mojom::EventResult)>> ack_callback(
       new base::Callback<void(mojom::EventResult)>(
           base::Bind(&mojom::WindowTree::OnWindowInputEventAck,
                      base::Unretained(tree_), event_id)));
-  window->input_event_handler_->OnWindowInputEvent(
-      window, *event.To<std::unique_ptr<ui::Event>>().get(), &ack_callback);
+
+  // TODO(moshayedi): crbug.com/617222. No need to convert to ui::MouseEvent or
+  // ui::TouchEvent once we have proper support for pointer events.
+  if (event->IsMousePointerEvent()) {
+    window->input_event_handler_->OnWindowInputEvent(
+        window, ui::MouseEvent(*event->AsPointerEvent()), &ack_callback);
+  } else if (event->IsTouchPointerEvent()) {
+    window->input_event_handler_->OnWindowInputEvent(
+        window, ui::TouchEvent(*event->AsPointerEvent()), &ack_callback);
+  } else {
+    window->input_event_handler_->OnWindowInputEvent(window, *event.get(),
+                                                     &ack_callback);
+  }
 
   // The handler did not take ownership of the callback, so we send the ack,
   // marking the event as not consumed.
   if (ack_callback)
     ack_callback->Run(mojom::EventResult::UNHANDLED);
 }
 
-void WindowTreeClient::OnEventObserved(mojom::EventPtr event,
-                                           uint32_t event_observer_id) {
-  if (has_event_observer_ && event_observer_id == event_observer_id_) {
-    std::unique_ptr<ui::Event> ui_event =
-        event.To<std::unique_ptr<ui::Event>>();
-    delegate_->OnEventObserved(*ui_event, nullptr /* target */);
-  }
+void WindowTreeClient::OnEventObserved(const std::unique_ptr<ui::Event>& event,
+                                       uint32_t event_observer_id) {
+  DCHECK(event);
+  if (has_event_observer_ && event_observer_id == event_observer_id_)
+    delegate_->OnEventObserved(*event.get(), nullptr /* target */);
 }
 
 void WindowTreeClient::OnWindowFocused(Id focused_window_id) {
   Window* focused_window = GetWindowByServerId(focused_window_id);
   InFlightFocusChange new_change(this, focused_window);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   LocalSetFocus(focused_window);
 }
@@ skipping 108 matching lines @@
 void WindowTreeClient::WmClientJankinessChanged(ClientSpecificId client_id,
                                                     bool janky) {
   if (window_manager_delegate_) {
     auto it = embedded_windows_.find(client_id);
     CHECK(it != embedded_windows_.end());
     window_manager_delegate_->OnWmClientJankinessChanged(
         embedded_windows_[client_id], janky);
   }
 }
 
-void WindowTreeClient::OnAccelerator(uint32_t id, mojom::EventPtr event) {
-  window_manager_delegate_->OnAccelerator(
-      id, *event.To<std::unique_ptr<ui::Event>>().get());
+void WindowTreeClient::OnAccelerator(uint32_t id,
+                                     const std::unique_ptr<ui::Event>& event) {
+  DCHECK(event);
+  window_manager_delegate_->OnAccelerator(id, *event.get());
 }
 
 void WindowTreeClient::SetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->WmSetFrameDecorationValues(
         std::move(values));
   }
 }
 
@@ skipping 38 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace mus