Drag and drop cleans up touch sequences from the source window.

ui/events/gestures/motion_event_aura_unittest.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include <cmath>
 
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 413 matching lines @@
   EXPECT_EQ(2U, cancel->GetPointerCount());
 }
 
 TEST(MotionEventAuraTest, ToolType) {
   MotionEventAura event;
   TouchEvent touch_event = TouchWithType(ET_TOUCH_PRESSED, 7);
   EXPECT_TRUE(event.OnTouch(touch_event));
   ASSERT_EQ(1U, event.GetPointerCount());
   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(0));
 
+  touch_event = TouchWithType(ET_TOUCH_RELEASED, 7);
   PointerDetails pointer_details(EventPointerType::POINTER_TYPE_PEN, 5.0f, 5.0f,
                                  1.0f, 0.0f, 0.0f);
   touch_event.set_pointer_details(pointer_details);
   EXPECT_TRUE(event.OnTouch(touch_event));
   EXPECT_EQ(MotionEvent::TOOL_TYPE_STYLUS, event.GetToolType(0));
 }
 
 TEST(MotionEventAuraTest, Flags) {
   int ids[] = {7, 11};
   MotionEventAura event;
 
   TouchEvent press0 = TouchWithType(ET_TOUCH_PRESSED, ids[0]);
   press0.set_flags(EF_CONTROL_DOWN);
   EXPECT_TRUE(event.OnTouch(press0));
   EXPECT_EQ(EF_CONTROL_DOWN, event.GetFlags());
 
   TouchEvent press1 = TouchWithType(ET_TOUCH_PRESSED, ids[1]);
   press1.set_flags(EF_CONTROL_DOWN | EF_CAPS_LOCK_ON);
   EXPECT_TRUE(event.OnTouch(press1));
   EXPECT_EQ(EF_CONTROL_DOWN | EF_CAPS_LOCK_ON, event.GetFlags());
 }
 
-// Once crbug.com/446852 is fixed, we should ignore redundant presses.
-TEST(MotionEventAuraTest, DoesntIgnoreRedundantPresses) {
+TEST(MotionEventAuraTest, IgnoresRedundantPresses) {
   const int id = 7;
   const int position_1 = 10;
   const int position_2 = 23;
 
   MotionEventAura event;
   TouchEvent press1 = TouchWithPosition(ET_TOUCH_PRESSED, id, position_1,
                                         position_1, position_1, position_1);
   EXPECT_TRUE(event.OnTouch(press1));
   TouchEvent press2 = TouchWithPosition(ET_TOUCH_PRESSED, id, position_2,
                                         position_2, position_2, position_2);
-  EXPECT_TRUE(event.OnTouch(press2));
+  EXPECT_FALSE(event.OnTouch(press2));
 
   EXPECT_EQ(1U, event.GetPointerCount());
-  EXPECT_FLOAT_EQ(position_2, event.GetX(0));
+  EXPECT_FLOAT_EQ(position_1, event.GetX(0));
 }
 
 TEST(MotionEventAuraTest, IgnoresEventsWithoutPress) {
   int id = 7;
   MotionEventAura event;
   EXPECT_FALSE(event.OnTouch(TouchWithType(ET_TOUCH_MOVED, id)));
 }
 
 TEST(MotionEventAuraTest, IgnoresStationaryMoves) {
   int id = 7;
   MotionEventAura event;
   EXPECT_TRUE(event.OnTouch(TouchWithType(ET_TOUCH_PRESSED, id)));
-  TouchEvent move0 = TouchWithPosition(ET_TOUCH_PRESSED, id, 10, 20, 10, 20);
+  TouchEvent move0 = TouchWithPosition(ET_TOUCH_MOVED, id, 10, 20, 10, 20);
   EXPECT_TRUE(event.OnTouch(move0));
 
   TouchEvent move1 = TouchWithPosition(ET_TOUCH_MOVED, id, 11, 21, 11, 21);
   EXPECT_TRUE(event.OnTouch(move1));
   EXPECT_FALSE(event.OnTouch(move1));
 }
 
 // Test after converting touch events into motion events, motion events should
 // have the same unique_event_id as touch events.
 TEST(MotionEventAuraTest, UniqueEventID) {
@@ skipping 31 matching lines @@
     int id = i + kIdOffset;
     TouchEvent release = TouchWithType(ET_TOUCH_RELEASED, id);
     if (i < MotionEvent::MAX_TOUCH_POINT_COUNT)
       EXPECT_TRUE(event.OnTouch(release));
     else
       EXPECT_FALSE(event.OnTouch(release));
   }
 }
 
 }  // namespace ui