Add the actual location coordinates to the touch cancel event

ui/aura/gestures/gesture_recognizer_unittest.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 "base/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 587 matching lines @@
     simulated_now_++;
   }
 };
 
 // An event handler to keep track of events.
 class TestEventHandler : public ui::EventHandler {
  public:
   TestEventHandler() : touch_released_count_(0),
                        touch_pressed_count_(0),
                        touch_moved_count_(0),
-                       touch_cancelled_count_(0) {
+                       touch_points_() {

[tdresser, 2014/08/13 19:57:57]

You don't need to initialize the std::vector.

[lanwei, 2014/08/14 00:38:45]

Done.

   }
 
   virtual ~TestEventHandler() {}
 
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     switch (event->type()) {
       case ui::ET_TOUCH_RELEASED:
         touch_released_count_++;
         break;
       case ui::ET_TOUCH_PRESSED:
         touch_pressed_count_++;
         break;
       case ui::ET_TOUCH_MOVED:
         touch_moved_count_++;
         break;
       case ui::ET_TOUCH_CANCELLED:
-        touch_cancelled_count_++;
+        touch_points_.push_back(event->location());
         break;
       default:
         break;
     }
   }
 
   void Reset() {
     touch_released_count_ = 0;
     touch_pressed_count_ = 0;
     touch_moved_count_ = 0;
-    touch_cancelled_count_ = 0;
+    touch_points_.clear();
   }
 
   int touch_released_count() const { return touch_released_count_; }
   int touch_pressed_count() const { return touch_pressed_count_; }
   int touch_moved_count() const { return touch_moved_count_; }
-  int touch_cancelled_count() const { return touch_cancelled_count_; }
+  int touch_cancelled_count() const { return (int) touch_points_.size(); }

[tdresser, 2014/08/13 19:57:58]

Use static_cast<int>(touch_points_.size());
We don't use C style casts in chromium.

[lanwei, 2014/08/14 00:38:46]

Done.

+  std::vector<gfx::PointF> touch_points() const { return touch_points_; }

[tdresser, 2014/08/13 19:57:57]

Return a const std::vector<gfx::PointF>&, to avoid copying the vector.

[lanwei, 2014/08/14 00:38:46]

Done.

 
  private:
   int touch_released_count_;
   int touch_pressed_count_;
   int touch_moved_count_;
-  int touch_cancelled_count_;
+  std::vector<gfx::PointF> touch_points_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
 };
 
 // Removes the target window from its parent when it receives a touch-cancel
 // event.
 class RemoveOnTouchCancelHandler : public TestEventHandler {
  public:
   RemoveOnTouchCancelHandler() {}
   virtual ~RemoveOnTouchCancelHandler() {}
@@ skipping 3103 matching lines @@
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 }
 
 TEST_P(GestureRecognizerTest,
        TransferEventDispatchesTouchCancel) {
+  // Disabled for not unified GR

[tdresser, 2014/08/13 19:57:57]

This is a little hard to read (double negative!)
Maybe try something like:

// Only enabled for unified GR, as the old Aura GR doesn't assign 
// positions to touch cancel events correctly.

[lanwei, 2014/08/14 00:38:46]

Done.

+  if (!UsingUnifiedGR())
+      return;
+
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 800;
   const int kWindowHeight = 600;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
-  scoped_ptr<RemoveOnTouchCancelHandler>

[tdresser, 2014/08/13 19:57:58]

We should be able to delete the RemoveOnTouchCancelHandler, shouldn't we?

[lanwei, 2014/08/14 00:38:45]

Done.

-      handler(new RemoveOnTouchCancelHandler());
+  scoped_ptr<TestEventHandler>

[tdresser, 2014/08/13 19:57:57]

Would this fit on one line?

[lanwei, 2014/08/14 00:38:46]

Done.

+      handler(new TestEventHandler());
   window->AddPreTargetHandler(handler.get());
 
   // Start a gesture sequence on |window|. Then transfer the events to NULL.
   // Make sure |window| receives a touch-cancel event.
   delegate->Reset();
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
                        kTouchId, tes.Now());
+  DispatchEventUsingWindowDispatcher(&press);
+  EXPECT_2_EVENTS(delegate->events(),
+                    ui::ET_GESTURE_BEGIN,

[tdresser, 2014/08/13 19:57:58]

These aren't indented correctly (silly eclipse). 
See
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Functi...
for details.

Check out "clang format" or git cl format, they can help with getting the
indentation right.

[lanwei, 2014/08/14 00:38:46]

Done.

+                    ui::ET_GESTURE_TAP_DOWN);
+  delegate->Reset();
   ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 1, tes.Now());

[tdresser, 2014/08/13 19:57:57]

Store the touch id in another const int, similar to what we're doing with
|kTouchId|.

[lanwei, 2014/08/14 00:38:45]

Done.

-  DispatchEventUsingWindowDispatcher(&press);
   DispatchEventUsingWindowDispatcher(&p2);
-  EXPECT_FALSE(delegate->tap());
-  EXPECT_TRUE(delegate->tap_down());
-  EXPECT_TRUE(delegate->tap_cancel());
-  EXPECT_TRUE(delegate->begin());
+  EXPECT_2_EVENTS(delegate->events(),
+                      ui::ET_GESTURE_TAP_CANCEL,
+                      ui::ET_GESTURE_BEGIN);
+  delegate->Reset();
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(350, 300), 1, tes.Now());
+  DispatchEventUsingWindowDispatcher(&move);
+  EXPECT_3_EVENTS(delegate->events(),
+                    ui::ET_GESTURE_SCROLL_BEGIN,
+                    ui::ET_GESTURE_SCROLL_UPDATE,
+                    ui::ET_GESTURE_PINCH_BEGIN);
   EXPECT_EQ(2, handler->touch_pressed_count());
   delegate->Reset();
   handler->Reset();
 
   ui::GestureRecognizer* gesture_recognizer = ui::GestureRecognizer::Get();
   EXPECT_EQ(window.get(),
             gesture_recognizer->GetTouchLockedTarget(press));
   gesture_recognizer->TransferEventsTo(window.get(), NULL);
   EXPECT_EQ(NULL,
             gesture_recognizer->GetTouchLockedTarget(press));
-  // The event-handler removes |window| from its parent on the first
-  // touch-cancel event, so it won't receive the second touch-cancel event.
-  EXPECT_EQ(1, handler->touch_cancelled_count());
+  EXPECT_4_EVENTS(delegate->events(),
+                      ui::ET_GESTURE_PINCH_END,
+                      ui::ET_GESTURE_SCROLL_END,
+                      ui::ET_GESTURE_END,
+                      ui::ET_GESTURE_END);
+  const std::vector<gfx::PointF>& points = handler->touch_points();
+  EXPECT_EQ(2, (int) points.size());

[tdresser, 2014/08/13 19:57:57]

To avoid the cast:
EXPECT_EQ(2U, points.size());

[lanwei, 2014/08/14 00:38:46]

Done.

+  EXPECT_EQ(gfx::Point(350, 300), points[0]);
+  EXPECT_EQ(gfx::Point(101, 201), points[1]);
 }
 
 // Check that appropriate touch events generate show press events
 TEST_P(GestureRecognizerTest, GestureEventShowPress) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
@@ skipping 753 matching lines @@
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->long_press());
 }
 
 INSTANTIATE_TEST_CASE_P(GestureRecognizer,
                         GestureRecognizerTest,
                         ::testing::Bool());
 
 }  // namespace test
 }  // namespace aura