Provide access to the WindowEventDispatcher as a ui::EventProcessor.

ui/aura/test/event_generator.cc

 // Copyright (c) 2012 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/aura/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 21 matching lines @@
 void DummyCallback(ui::EventType, const gfx::Vector2dF&) {
 }
 
 class DefaultEventGeneratorDelegate : public EventGeneratorDelegate {
  public:
   explicit DefaultEventGeneratorDelegate(Window* root_window)
       : root_window_(root_window) {}
   virtual ~DefaultEventGeneratorDelegate() {}
 
   // EventGeneratorDelegate overrides:
-  virtual WindowEventDispatcher* GetDispatcherAt(
-      const gfx::Point& point) const OVERRIDE {
-    return root_window_->GetHost()->dispatcher();
+  virtual WindowTreeHost* GetHostAt(const gfx::Point& point) const OVERRIDE {
+    return root_window_->GetHost();
   }
 
   virtual client::ScreenPositionClient* GetScreenPositionClient(
       const aura::Window* window) const OVERRIDE {
     return NULL;
   }
 
  private:
   Window* root_window_;
 
@@ skipping 21 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(TestTouchEvent);
 };
 
 const int kAllButtonMask = ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON;
 
 }  // namespace
 
 EventGenerator::EventGenerator(Window* root_window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
-      current_dispatcher_(delegate_->GetDispatcherAt(current_location_)),
+      current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
 EventGenerator::EventGenerator(Window* root_window, const gfx::Point& point)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(point),
-      current_dispatcher_(delegate_->GetDispatcherAt(current_location_)),
+      current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
 EventGenerator::EventGenerator(Window* root_window, Window* window)
     : delegate_(new DefaultEventGeneratorDelegate(root_window)),
       current_location_(CenterOfWindow(window)),
-      current_dispatcher_(delegate_->GetDispatcherAt(current_location_)),
+      current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
-      current_dispatcher_(delegate_->GetDispatcherAt(current_location_)),
+      current_host_(delegate_->GetHostAt(current_location_)),
       flags_(0),
       grab_(false),
       async_(false) {
 }
 
 EventGenerator::~EventGenerator() {
   for (std::list<ui::Event*>::iterator i = pending_events_.begin();
       i != pending_events_.end(); ++i)
     delete *i;
   pending_events_.clear();
@@ skipping 22 matching lines @@
 void EventGenerator::PressRightButton() {
   PressButton(ui::EF_RIGHT_MOUSE_BUTTON);
 }
 
 void EventGenerator::ReleaseRightButton() {
   ReleaseButton(ui::EF_RIGHT_MOUSE_BUTTON);
 }
 
 void EventGenerator::SendMouseExit() {
   gfx::Point exit_location(current_location_);
-  ConvertPointToTarget(current_dispatcher_->window(), &exit_location);
+  ConvertPointToTarget(current_host_->window(), &exit_location);
   ui::MouseEvent mouseev(ui::ET_MOUSE_EXITED, exit_location, exit_location,
                          flags_, 0);
   Dispatch(&mouseev);
 }
 
 void EventGenerator::MoveMouseToInHost(const gfx::Point& point_in_host) {
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
   ui::MouseEvent mouseev(event_type, point_in_host, point_in_host, flags_, 0);
   Dispatch(&mouseev);
 
   current_location_ = point_in_host;
-  current_dispatcher_->host()->ConvertPointFromHost(&current_location_);
+  current_host_->ConvertPointFromHost(&current_location_);
 }
 
 void EventGenerator::MoveMouseTo(const gfx::Point& point_in_screen,
                                  int count) {
   DCHECK_GT(count, 0);
   const ui::EventType event_type = (flags_ & ui::EF_LEFT_MOUSE_BUTTON) ?
       ui::ET_MOUSE_DRAGGED : ui::ET_MOUSE_MOVED;
 
   gfx::Vector2dF diff(point_in_screen - current_location_);
   for (float i = 1; i <= count; i++) {
     gfx::Vector2dF step(diff);
     step.Scale(i / count);
     gfx::Point move_point = current_location_ + gfx::ToRoundedVector2d(step);
     if (!grab_)
       UpdateCurrentDispatcher(move_point);
-    ConvertPointToTarget(current_dispatcher_->window(), &move_point);
+    ConvertPointToTarget(current_host_->window(), &move_point);
     ui::MouseEvent mouseev(event_type, move_point, move_point, flags_, 0);
     Dispatch(&mouseev);
   }
   current_location_ = point_in_screen;
 }
 
 void EventGenerator::MoveMouseRelativeTo(const Window* window,
                                          const gfx::Point& point_in_parent) {
   gfx::Point point(point_in_parent);
   ConvertPointFromTarget(window, &point);
@@ skipping 323 matching lines @@
                       flags);
   ui::KeyEvent keyev(xevent, false);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
   ui::KeyEvent keyev(type, key_code, flags, false);
 #endif  // OS_WIN
   Dispatch(&keyev);
 }
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
-  current_dispatcher_ = delegate_->GetDispatcherAt(point);
+  current_host_ = delegate_->GetHostAt(point);
 }
 
 void EventGenerator::PressButton(int flag) {
   if (!(flags_ & flag)) {
     flags_ |= flag;
     grab_ = flags_ & kAllButtonMask;
     gfx::Point location = GetLocationInCurrentRoot();
     ui::MouseEvent mouseev(ui::ET_MOUSE_PRESSED, location, location, flags_,
                            flag);
     Dispatch(&mouseev);
@@ skipping 28 matching lines @@
   aura::client::ScreenPositionClient* client =
       delegate_->GetScreenPositionClient(target);
   if (client)
     client->ConvertPointFromScreen(target, point);
   else
     aura::Window::ConvertPointToTarget(target->GetRootWindow(), target, point);
 }
 
 gfx::Point EventGenerator::GetLocationInCurrentRoot() const {
   gfx::Point p(current_location_);
-  ConvertPointToTarget(current_dispatcher_->window(), &p);
+  ConvertPointToTarget(current_host_->window(), &p);
   return p;
 }
 
 gfx::Point EventGenerator::CenterOfWindow(const Window* window) const {
   gfx::Point center = gfx::Rect(window->bounds().size()).CenterPoint();
   ConvertPointFromTarget(window, &center);
   return center;
 }
 
 void EventGenerator::DoDispatchEvent(ui::Event* event, bool async) {
@@ skipping 13 matching lines @@
       return;
     }
     if (pending_events_.empty()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(&EventGenerator::DispatchNextPendingEvent,
                      base::Unretained(this)));
     }
     pending_events_.push_back(pending_event);
   } else {
-    ui::EventDispatchDetails details = current_dispatcher_->OnEventFromSource(
-        event);
+    ui::EventDispatchDetails details =
+        current_host_->event_processor()->OnEventFromSource(event);
     CHECK(!details.dispatcher_destroyed);
   }
 }
 
 void EventGenerator::DispatchNextPendingEvent() {
   DCHECK(!pending_events_.empty());
   ui::Event* event = pending_events_.front();
   DoDispatchEvent(event, false);
   pending_events_.pop_front();
   delete event;
   if (!pending_events_.empty()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(&EventGenerator::DispatchNextPendingEvent,
                    base::Unretained(this)));
   }
 }
 
 
 }  // namespace test
 }  // namespace aura