mus: Fix handled status in UI event ack, add MessageLoop::NestingObserver

ui/views/mus/platform_window_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/platform_window_mus.h"
 
+#include "base/message_loop/message_loop.h"
 #include "build/build_config.h"
 #include "components/bitmap_uploader/bitmap_uploader.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "ui/base/view_prop.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #include "ui/views/mus/window_manager_connection.h"
 
+using mus::mojom::EventResult;
+
 namespace views {
 
 namespace {
+
 static uint32_t accelerated_widget_count = 1;
 
 }  // namespace
 
 PlatformWindowMus::PlatformWindowMus(ui::PlatformWindowDelegate* delegate,
                                      shell::Connector* connector,
                                      mus::Window* mus_window)
     : delegate_(delegate),
       mus_window_(mus_window),
       show_state_(mus::mojom::ShowState::RESTORED),
       last_cursor_(mus::mojom::Cursor::CURSOR_NULL),
       mus_window_destroyed_(false) {
   DCHECK(delegate_);
   DCHECK(mus_window_);
   mus_window_->AddObserver(this);
   mus_window_->set_input_event_handler(this);
+  base::MessageLoop::current()->AddNestingObserver(this);
 
   // We need accelerated widget numbers to be different for each
   // window and fit in the smallest sizeof(AcceleratedWidget) uint32_t
   // has this property.
 #if defined(OS_WIN) || defined(OS_ANDROID)
   gfx::AcceleratedWidget accelerated_widget =
       reinterpret_cast<gfx::AcceleratedWidget>(accelerated_widget_count++);
 #else
   gfx::AcceleratedWidget accelerated_widget =
       static_cast<gfx::AcceleratedWidget>(accelerated_widget_count++);
 #endif
   delegate_->OnAcceleratedWidgetAvailable(
       accelerated_widget, mus_window_->viewport_metrics().device_pixel_ratio);
 
   bitmap_uploader_.reset(new bitmap_uploader::BitmapUploader(mus_window_));
   bitmap_uploader_->Init(connector);
   prop_.reset(new ui::ViewProp(
       accelerated_widget, bitmap_uploader::kBitmapUploaderForAcceleratedWidget,
       bitmap_uploader_.get()));
 }
 
 PlatformWindowMus::~PlatformWindowMus() {
+  base::MessageLoop::current()->RemoveNestingObserver(this);
   if (!mus_window_)
     return;
   mus_window_->RemoveObserver(this);
   mus_window_->set_input_event_handler(nullptr);
   if (!mus_window_destroyed_)
     mus_window_->Destroy();
 }
 
 void PlatformWindowMus::Activate() {
   mus_window_->SetFocus();
@@ skipping 147 matching lines @@
   }
   delegate_->OnWindowStateChanged(state);
 }
 
 void PlatformWindowMus::OnRequestClose(mus::Window* window) {
   delegate_->OnCloseRequest();
 }
 
 void PlatformWindowMus::OnWindowInputEvent(
     mus::Window* view,
-    const ui::Event& event,
-    std::unique_ptr<base::Callback<void(mus::mojom::EventResult)>>*
-        ack_callback) {
-  // It's possible dispatching the event will spin a nested message loop. Ack
-  // the callback now, otherwise we appear unresponsive for the life of the
-  // nested message loop.
-  (*ack_callback)->Run(mus::mojom::EventResult::HANDLED);
-  ack_callback->reset();
-  // TODO(moshayedi): Avoid cloning after updating PlatformWindowDelegate to
-  // accept constant pointers.
-  delegate_->DispatchEvent(ui::Event::Clone(event).get());
+    const ui::Event& event_in,
+    std::unique_ptr<base::Callback<void(EventResult)>>* ack_callback) {
+  event_ack_callback_ = std::move(*ack_callback);

[sky, 2016/04/16 16:28:33]

I have a feeling you need to deal with multiple nestings (you only deal with one
here). I think a menu that triggers dnd may cause multiple nestings.

+
+  // DispatchEvent requires a mutable event so flags like handled can be set.
+  scoped_ptr<ui::Event> event = ui::Event::Clone(event_in);

[sky, 2016/04/16 16:28:33]

std::unique_ptr

+  delegate_->DispatchEvent(event.get());
+
+  // If the event wasn't already handled by a nested message loop then ack it
+  // with the handled state.
+  if (event_ack_callback_) {

[sky, 2016/04/16 16:28:33]

In addition to multiple nestings you should deal with this being deleted during
the dispatch.

+    event_ack_callback_->Run(
+        event->handled() ? EventResult::HANDLED : EventResult::UNHANDLED);
+    event_ack_callback_.reset();
+  }
+}
+
+void PlatformWindowMus::OnBeginNestedMessageLoop() {
+  // It's possible dispatching an event will spin a nested message loop. If we
+  // are processing an event then ack the callback now, otherwise we appear
+  // unresponsive for the life of the nested message loop.
+  if (event_ack_callback_) {
+    event_ack_callback_->Run(EventResult::HANDLED);
+    event_ack_callback_.reset();
+  }
 }
 
 }  // namespace views