mash: Convert OnWindowInputEventAck to use an enum for handled status

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_);
 
   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 112 matching lines @@
 
   base::WeakPtr<Accelerator> weak_accelerator;
   if (accelerator)
     weak_accelerator = accelerator->GetWeakPtr();
   DispatchInputEventToWindowImpl(target, in_nonclient_area, event,
                                  weak_accelerator);
 }
 
 }  // namespace ws
 }  // namespace mus