aura: Remove WindowTreeHost::PostNativeEvent().

ui/aura/test/ui_controls_factory_ozone.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 "base/bind.h"
 #include "base/logging.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/aura_test_utils.h"
 #include "ui/aura/test/ui_controls_factory_aura.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/test/ui_controls_aura.h"
+#include "ui/events/test/events_test_utils.h"
 
 namespace aura {
 namespace test {
 namespace {
 
 class UIControlsOzone : public ui_controls::UIControlsAura {
  public:
   UIControlsOzone(WindowTreeHost* host) : host_(host) {}
 
   virtual bool SendKeyPress(gfx::NativeWindow window,
@@ skipping 135 matching lines @@
   virtual bool SendMouseClick(ui_controls::MouseButton type) override {
     return SendMouseEvents(type, ui_controls::UP | ui_controls::DOWN);
   }
   virtual void RunClosureAfterAllPendingUIEvents(
       const base::Closure& closure) override {
     if (!closure.is_null())
       base::MessageLoop::current()->PostTask(FROM_HERE, closure);
   }
 
  private:
+  void SendEventToProcessor(ui::Event* event) {

[sky, 2014/11/07 15:50:14]

Is there a reason this needs to be a pointer? I briefly looked at why
SendEventToProcessor, but it isn't clear why that needs a pointer too.

[sadrul, 2014/11/07 17:03:15]

This is mostly so the consumers can do SetHandled()/StopPropagation() on the
event.

+    ui::EventSourceTestApi event_source_test(host_->GetEventSource());
+    ui::EventDispatchDetails details =
+        event_source_test.SendEventToProcessor(event);
+    if (details.dispatcher_destroyed)
+      return;
+  }
+
   void PostKeyEvent(ui::EventType type, ui::KeyboardCode key_code, int flags) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&UIControlsOzone::PostKeyEventTask,
                    base::Unretained(this),
                    type,
                    key_code,
                    flags));
   }
 
   void PostKeyEventTask(ui::EventType type,
                         ui::KeyboardCode key_code,
                         int flags) {
     // Do not rewrite injected events. See crbug.com/136465.
     flags |= ui::EF_FINAL;
 
     ui::KeyEvent key_event(type, key_code, flags);
-    host_->PostNativeEvent(&key_event);
+    SendEventToProcessor(&key_event);
   }
 
   void PostMouseEvent(ui::EventType type,
                       const gfx::PointF& location,
                       int flags,
                       int changed_button_flags) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&UIControlsOzone::PostMouseEventTask,
                    base::Unretained(this),
                    type,
                    location,
                    flags,
                    changed_button_flags));
   }
 
   void PostMouseEventTask(ui::EventType type,
                           const gfx::PointF& location,
                           int flags,
                           int changed_button_flags) {
     ui::MouseEvent mouse_event(
         type, location, location, flags, changed_button_flags);
 
     // This hack is necessary to set the repeat count for clicks.
     ui::MouseEvent mouse_event2(&mouse_event);
 
-    host_->PostNativeEvent(&mouse_event2);
+    SendEventToProcessor(&mouse_event2);
   }
 
   WindowTreeHost* host_;
 
   // Mask of the mouse buttons currently down.
   unsigned button_down_mask_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(UIControlsOzone);
 };
 
 }  // namespace
 
 ui_controls::UIControlsAura* CreateUIControlsAura(WindowTreeHost* host) {
   return new UIControlsOzone(host);
 }
 
 }  // namespace test
 }  // namespace aura