mash: Repost mouse pressed event when closing Ash system tray

components/mus/ws/window_manager_state.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/mus/ws/window_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/platform_display.h"
@@ skipping 142 matching lines @@
   display_ptr->frame_decoration_values = frame_decoration_values_.Clone();
   return display_ptr;
 }
 
 void WindowManagerState::OnWillDestroyTree(WindowTree* tree) {
   if (tree_awaiting_input_ack_ != tree)
     return;
   // The WindowTree is dying. So it's not going to ack the event.
   // If the dying tree matches the root |tree_| marked as handled so we don't
   // notify it of accelerators.
-  OnEventAck(tree_awaiting_input_ack_, tree == tree_);
+  OnEventAck(tree_awaiting_input_ack_, tree == tree_
+                                           ? mojom::EventResult::HANDLED
+                                           : mojom::EventResult::UNHANDLED);
 }
 
 WindowManagerState::WindowManagerState(Display* display,
                                        PlatformDisplay* platform_display,
                                        cc::SurfaceId surface_id,
                                        bool is_user_id_valid,
                                        const UserId& user_id)
     : display_(display),
       platform_display_(platform_display),
       is_user_id_valid_(is_user_id_valid),
@@ skipping 46 matching lines @@
       event_queue_.back()->event = CoalesceEvents(
           std::move(event_queue_.back()->event), ui::Event::Clone(event));
       return;
     }
     QueueEvent(event, nullptr);
     return;
   }
   event_dispatcher_.ProcessEvent(event);
 }
 
-void WindowManagerState::OnEventAck(mojom::WindowTree* tree, bool handled) {
+void WindowManagerState::OnEventAck(mojom::WindowTree* tree,
+                                    mojom::EventResult result) {
   if (tree_awaiting_input_ack_ != tree) {
     // TODO(sad): The ack must have arrived after the timeout. We should do
     // something here, and in OnEventAckTimeout().
     return;
   }
   tree_awaiting_input_ack_ = nullptr;
   event_ack_timer_.Stop();
 
-  if (!handled && post_target_accelerator_)
+  if (result == mojom::EventResult::UNHANDLED && post_target_accelerator_) {
     OnAccelerator(post_target_accelerator_->id(), *event_awaiting_input_ack_);
+  } else if (result == mojom::EventResult::REPOST) {
+    scoped_ptr<ui::Event> event = ui::Event::Clone(*event_awaiting_input_ack_);
+    // The cached event may have had its location transformed to a window
+    // target. Use its original coordinates when reposting so it can be
+    // transformed to other targets.
+    if (event->IsPointerEvent()) {
+      ui::PointerEvent* pointer_event = event->AsPointerEvent();
+      pointer_event->set_location(pointer_event->root_location());
+    }
+    event_dispatcher_.ProcessEvent(*event);
+  }
 
   ProcessNextEventFromQueue();
 }
 
 WindowServer* WindowManagerState::window_server() {
   return display_->window_server();
 }
 
 void WindowManagerState::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
-  OnEventAck(tree_awaiting_input_ack_, false);
+  OnEventAck(tree_awaiting_input_ack_, mojom::EventResult::UNHANDLED);
 }
 
 void WindowManagerState::QueueEvent(
     const ui::Event& event,
     scoped_ptr<ProcessedEventTarget> processed_event_target) {
   scoped_ptr<QueuedEvent> queued_event(new QueuedEvent);
   queued_event->event = ui::Event::Clone(event);
   queued_event->processed_target = std::move(processed_event_target);
   event_queue_.push(std::move(queued_event));
 }
@@ skipping 14 matching lines @@
           queued_event->processed_target->in_nonclient_area(),
           *queued_event->event, queued_event->processed_target->accelerator());
       return;
     }
   }
 }
 
 void WindowManagerState::DispatchInputEventToWindowImpl(
     ServerWindow* target,
     bool in_nonclient_area,
-    const ui::Event& event,
+    const ui::Event& transformed_event,
     base::WeakPtr<Accelerator> accelerator) {
   if (target == root_->parent())
     target = root_.get();
 
-  if (event.IsMousePointerEvent()) {
+  if (transformed_event.IsMousePointerEvent()) {
     DCHECK(event_dispatcher_.mouse_cursor_source_window());
     display_->UpdateNativeCursor(
         event_dispatcher_.mouse_cursor_source_window()->cursor());
   }
 
   // If the event is in the non-client area the event goes to the owner of
   // the window. Otherwise if the window is an embed root, forward to the
   // embedded window.
   WindowTree* tree =
       in_nonclient_area
@@ skipping 12 matching lines @@
   }
 
   // TOOD(sad): Adjust this delay, possibly make this dynamic.
   const base::TimeDelta max_delay = base::debug::BeingDebugged()
                                         ? base::TimeDelta::FromDays(1)
                                         : GetDefaultAckTimerDelay();
   event_ack_timer_.Start(FROM_HERE, max_delay, this,
                          &WindowManagerState::OnEventAckTimeout);
 
   tree_awaiting_input_ack_ = tree;
+  event_awaiting_input_ack_ = ui::Event::Clone(transformed_event);
   if (accelerator) {
-    event_awaiting_input_ack_ = ui::Event::Clone(event);
     post_target_accelerator_ = accelerator;
   }
-  tree->DispatchInputEvent(target, event);
+  tree->DispatchInputEvent(target, transformed_event);
 }
 
 void WindowManagerState::OnAccelerator(uint32_t accelerator_id,
                                        const ui::Event& event) {
   DCHECK(IsActive());
   tree_->OnAccelerator(accelerator_id, event);
 }
 
 void WindowManagerState::SetFocusedWindowFromEventDispatcher(
     ServerWindow* new_focused_window) {
@@ skipping 12 matching lines @@
 
 void WindowManagerState::ReleaseNativeCapture() {
   platform_display_->ReleaseCapture();
 }
 
 void WindowManagerState::OnServerWindowCaptureLost(ServerWindow* window) {
   DCHECK(window);
   window_server()->ProcessLostCapture(window);
 }
 
-void WindowManagerState::DispatchInputEventToWindow(ServerWindow* target,
-                                                    bool in_nonclient_area,
-                                                    const ui::Event& event,
-                                                    Accelerator* accelerator) {
+void WindowManagerState::DispatchInputEventToWindow(
+    ServerWindow* target,
+    bool in_nonclient_area,
+    const ui::Event& transformed_event,
+    Accelerator* accelerator) {
   DCHECK(IsActive());
   // TODO(sky): this needs to see if another wms has capture and if so forward
   // to it.
   if (event_ack_timer_.IsRunning()) {
     scoped_ptr<ProcessedEventTarget> processed_event_target(
         new ProcessedEventTarget(target, in_nonclient_area, accelerator));
-    QueueEvent(event, std::move(processed_event_target));
+    QueueEvent(transformed_event, std::move(processed_event_target));
     return;
   }
 
   base::WeakPtr<Accelerator> weak_accelerator;
   if (accelerator)
     weak_accelerator = accelerator->GetWeakPtr();
-  DispatchInputEventToWindowImpl(target, in_nonclient_area, event,
+  DispatchInputEventToWindowImpl(target, in_nonclient_area, transformed_event,
                                  weak_accelerator);
 }
 
 }  // namespace ws
 }  // namespace mus