Convert ui::GestureEvent coordinates during targeting

ui/events/event_processor_unittest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_targeter.h"
 #include "ui/events/test/events_test_utils.h"
@@ skipping 152 matching lines @@
                     EF_NONE, EF_NONE);
   DispatchEvent(&second);
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(parent_r->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(child_r->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(grandchild_r->DidReceiveEvent(ET_MOUSE_MOVED));
 }
 
 // ReDispatchEventHandler is used to receive mouse events and forward them
 // to a specified EventProcessor. Verifies that the event has the correct
-// target and phase both before and after the nested event processing.
+// target and phase both before and after the nested event processing. Also
+// verifies that the location of the event remains the same after it has
+// been processed by the second EventProcessor.
 class ReDispatchEventHandler : public TestEventHandler {
  public:
   ReDispatchEventHandler(EventProcessor* processor, EventTarget* target)
       : processor_(processor), expected_target_(target) {}
   virtual ~ReDispatchEventHandler() {}
 
   // TestEventHandler:
   virtual void OnMouseEvent(MouseEvent* event) OVERRIDE {
     TestEventHandler::OnMouseEvent(event);
 
     EXPECT_EQ(expected_target_, event->target());
     EXPECT_EQ(EP_TARGET, event->phase());
 
+    gfx::Point location(event->location());
     EventDispatchDetails details = processor_->OnEventFromSource(event);
     EXPECT_FALSE(details.dispatcher_destroyed);
     EXPECT_FALSE(details.target_destroyed);
 
-    // The nested event-processing should not have mutated the target or
-    // phase of |event|.
+    // The nested event-processing should not have mutated the target,
+    // phase, or location of |event|.
     EXPECT_EQ(expected_target_, event->target());
     EXPECT_EQ(EP_TARGET, event->phase());
+    EXPECT_EQ(location, event->location());
   }
 
  private:
   EventProcessor* processor_;
   EventTarget* expected_target_;
 
   DISALLOW_COPY_AND_ASSIGN(ReDispatchEventHandler);
 };
 
 // Verifies that the phase and target information of an event is not mutated
@@ skipping 245 matching lines @@
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui