ash: ozone: apply transformation to events outside the root window

ui/events/test/event_generator.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 "ui/events/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 395 matching lines @@
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     float x_offset,
                                     float y_offset,
                                     int steps,
                                     int num_fingers) {
   base::TimeDelta timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
+                               start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   float dx = x_offset / steps;
   float dy = y_offset / steps;
   for (int i = 0; i < steps; ++i) {
     timestamp += step_delay;
     ui::ScrollEvent move(ui::ET_SCROLL,
                          start,
+                         start,
                          timestamp,
                          0,
                          dx, dy,
                          dx, dy,
                          num_fingers);
     Dispatch(&move);
   }
 
   ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
                               start,
+                              start,
                               timestamp,
                               0,
                               x_offset, y_offset,
                               x_offset, y_offset,
                               num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::ScrollSequence(const gfx::Point& start,
                                     const base::TimeDelta& step_delay,
                                     const std::vector<gfx::PointF>& offsets,
                                     int num_fingers) {
   size_t steps = offsets.size();
   base::TimeDelta timestamp = Now();
   ui::ScrollEvent fling_cancel(ui::ET_SCROLL_FLING_CANCEL,
                                start,
+                               start,
                                timestamp,
                                0,
                                0, 0,
                                0, 0,
                                num_fingers);
   Dispatch(&fling_cancel);
 
   for (size_t i = 0; i < steps; ++i) {
     timestamp += step_delay;
     ui::ScrollEvent scroll(ui::ET_SCROLL,
                            start,
+                           start,
                            timestamp,
                            0,
                            offsets[i].x(), offsets[i].y(),
                            offsets[i].x(), offsets[i].y(),
                            num_fingers);
     Dispatch(&scroll);
   }
 
   ui::ScrollEvent fling_start(ui::ET_SCROLL_FLING_START,
                               start,
+                              start,
                               timestamp,
                               0,
                               offsets[steps - 1].x(), offsets[steps - 1].y(),
                               offsets[steps - 1].x(), offsets[steps - 1].y(),
                               num_fingers);
   Dispatch(&fling_start);
 }
 
 void EventGenerator::PressKey(ui::KeyboardCode key_code, int flags) {
   DispatchKeyEvent(true, key_code, flags);
@@ skipping 147 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui