mus: Introduce API for embedder to dispatch event to the embeded client.

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 12 matching lines @@
 #include "components/mus/public/cpp/window_tree_client_observer.h"
 #include "components/mus/public/interfaces/window_manager_window_tree_factory.mojom.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/display/mojo/display_type_converters.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace mus {
 
+namespace {
+
 void DeleteWindowTreeClient(WindowTreeClient* client) { delete client; }
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
 Id server_id(Window* window) {
   return WindowPrivate(window).server_id();
 }
 
@@ skipping 11 matching lines @@
   private_window.set_properties(
       window_data->properties
           .To<std::map<std::string, std::vector<uint8_t>>>());
   client->AddWindow(window);
   private_window.LocalSetBounds(gfx::Rect(), window_data->bounds);
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
   return window;
 }
 
+}  // namespace
+
 Window* BuildWindowTree(WindowTreeClient* client,
                         const mojo::Array<mojom::WindowDataPtr>& windows,
                         Window* initial_parent) {
   std::vector<Window*> parents;
   Window* root = NULL;
   Window* last_window = NULL;
   if (initial_parent)
     parents.push_back(initial_parent);
   for (size_t i = 0; i < windows.size(); ++i) {
     if (last_window && windows[i]->parent_id == server_id(last_window)) {
@@ skipping 19 matching lines @@
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       capture_window_(nullptr),
       focused_window_(nullptr),
       binding_(this),
       tree_(nullptr),
       delete_on_no_roots_(!window_manager_delegate),
       in_destructor_(false),
+      event_handler_binding_(this),
       weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
@@ skipping 883 matching lines @@
   if (!window)
     return;
 
   InFlightPredefinedCursorChange new_change(window, cursor);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
   WindowPrivate(window).LocalSetPredefinedCursor(cursor);
 }
 
+void X() {
+  LOG(ERROR) << "FFFFFFFFFFFFFFFFUCK";
+}
+
+void WindowTreeClient::RequestInputEventHandler(
+    mojom::InputEventHandlerRequest request) {
+  LOG(ERROR) << "Yes";
+  event_handler_binding_.Bind(std::move(request));
+  event_handler_binding_.set_connection_error_handler(base::Bind(&X));
+}
+
 void WindowTreeClient::OnChangeCompleted(uint32_t change_id, bool success) {
   std::unique_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
   in_flight_map_.erase(change_id);
   if (!change)
     return;
 
   if (!success)
     change->ChangeFailed();
 
   InFlightChange* next_change = GetOldestInFlightChangeMatching(*change);
@@ skipping 155 matching lines @@
 void WindowTreeClient::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     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);
   }
 }
 
+void WindowTreeClient::OnInputEvent(uint32_t window_id,
+                                    std::unique_ptr<ui::Event> event,
+                                    const OnInputEventCallback& callback) {
+  Window* window = GetWindowByServerId(window_id);  // May be null.
+  LOG(ERROR) << "X: " << event->name() << " " << window << " " << window_id
+      << " " << windows_.size();
+  if (!window && !windows_.empty())
+    window = windows_.begin()->second;
+  if (window && window->input_event_handler_) {
+    window->input_event_handler_->OnWindowInputEvent(window, *event, nullptr);
+  }
+  callback.Run(true);
+}
+
 }  // namespace mus