Do not emit OnActiveTouchesCanceled if cancel did not happen

As is reported in the bug, the window service receives too many
mojo messages for CancelActiveTouches, and that's because
it always sends the messages every time CancelActiveTouches is
requested. But it doesn't have to send it if nothing has to be
canceled.

BUG=899429
TEST=manually, and the new test case covers

Change-Id: I26b0234ef9e541b5dc31623d27162a0ea374bb54
Reviewed-on: https://chromium-review.googlesource.com/c/1305235
Commit-Queue: Jun Mukai <mukai@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Timothy Dresser <tdresser@chromium.org>
Cr-Commit-Position: refs/heads/master@{#603744}

ui/aura/mus/gesture_synchronizer_unittest.cc

@@ -12,6 +12,9 @@
 #include "ui/aura/mus/window_tree_host_mus_init_params.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
+#include "ui/aura/test/test_window_delegate.h"
+#include "ui/aura/test/test_windows.h"
+#include "ui/events/test/event_generator.h"
 
 namespace aura {
 
@@ -20,31 +23,17 @@ class GestureSynchronizerTest : public test::AuraMusClientTestBase {
   GestureSynchronizerTest() = default;
   ~GestureSynchronizerTest() override = default;
 
-  void SetUp() override {
-    test::AuraMusClientTestBase::SetUp();
-
-    window_tree_host_ = std::make_unique<WindowTreeHostMus>(
-        CreateInitParamsForTopLevel(window_tree_client_impl()));
-    window_tree_host_->InitHost();
-    window_tree_host_->Show();
-  }
-
  protected:
   ui::GestureRecognizer* gesture_recognizer() {
     return Env::GetInstance()->gesture_recognizer();
   }
 
-  std::unique_ptr<Window> NewWindow() {
-    auto window = std::make_unique<Window>(nullptr);
-    window->Init(ui::LAYER_NOT_DRAWN);
-    window_tree_host_->window()->AddChild(window.get());
-    window->Show();
-    return window;
+  std::unique_ptr<Window> NewWindow(aura::WindowDelegate* delegate = nullptr) {
+    return std::unique_ptr<Window>(aura::test::CreateTestWindowWithDelegate(
+        delegate, 0, gfx::Rect(0, 0, 100, 100), root_window()));
   }
 
  private:
-  std::unique_ptr<WindowTreeHostMus> window_tree_host_;
-
   DISALLOW_COPY_AND_ASSIGN(GestureSynchronizerTest);
 };
 
@@ -61,12 +50,23 @@ TEST_F(GestureSynchronizerTest, CancelActiveTouchesExceptForNullptr) {
 }
 
 TEST_F(GestureSynchronizerTest, CancelActiveTouches) {
-  std::unique_ptr<Window> window = NewWindow();
+  aura::test::TestWindowDelegate delegate;
+  std::unique_ptr<Window> window = NewWindow(&delegate);
+  ui::test::EventGenerator event_generator(root_window());
+  event_generator.MoveTouch(window->GetBoundsInScreen().CenterPoint());
+  event_generator.PressTouch();
   gesture_recognizer()->CancelActiveTouches(window.get());
   EXPECT_EQ(window_tree()->last_cancelled_window_id(),
             WindowMus::Get(window.get())->server_id());
 }
 
+TEST_F(GestureSynchronizerTest, CancelActiveTouchesNotSentWithoutTouches) {
+  aura::test::TestWindowDelegate delegate;
+  std::unique_ptr<Window> window = NewWindow(&delegate);
+  gesture_recognizer()->CancelActiveTouches(window.get());
+  EXPECT_EQ(window_tree()->last_cancelled_window_id(), 0u);
+}
+
 TEST_F(GestureSynchronizerTest, TransferGestureEventsTo) {
   std::unique_ptr<Window> window1 = NewWindow();
   std::unique_ptr<Window> window2 = NewWindow();

ui/events/gestures/gesture_recognizer_impl.cc

@@ -337,13 +337,15 @@ bool GestureRecognizerImpl::CancelActiveTouchesImpl(
 
   std::vector<std::unique_ptr<TouchEvent>> cancelling_touches =
       GetEventPerPointForConsumer(consumer, ET_TOUCH_CANCELLED);
+  if (cancelling_touches.empty())
+    return false;
   for (const std::unique_ptr<TouchEvent>& cancelling_touch : cancelling_touches)
     helper->DispatchSyntheticTouchEvent(cancelling_touch.get());
   if (should_notify == kNotifyObservers) {
     for (GestureRecognizerObserver& observer : observers())
       observer.OnActiveTouchesCanceled(consumer);
   }
-  return !cancelling_touches.empty();
+  return true;
 }
 
 bool GestureRecognizerImpl::CleanupStateForConsumer(

ui/events/gestures/gesture_recognizer_impl_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "ui/events/gestures/gesture_recognizer_impl.h"
 
+#include "base/message_loop/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/gestures/gesture_recognizer_observer.h"
 
@@ -118,14 +119,26 @@ class GestureRecognizerImplTest : public testing::Test {
   GestureRecognizerImpl gesture_recognizer_;
   TestGestureEventHelper helper_;
   std::unique_ptr<TestGestureRecognizerObserver> observer_;
+  base::MessageLoopForUI message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureRecognizerImplTest);
 };
 
-TEST_F(GestureRecognizerImplTest, CancelActiveTouchEvents) {
+TEST_F(GestureRecognizerImplTest, CancelActiveTouchesNoCancellations) {
   GestureConsumer consumer;
   gesture_recognizer()->CancelActiveTouches(&consumer);
 
+  EXPECT_EQ(0, observer()->active_touches_cancelled_call_count());
+  EXPECT_FALSE(observer()->last_cancelled());
+}
+
+TEST_F(GestureRecognizerImplTest, CancelActiveTouches) {
+  GestureConsumer consumer;
+  TouchEvent event(ET_TOUCH_PRESSED, gfx::Point(), base::TimeTicks::Now(),
+                   PointerDetails());
+  gesture_recognizer()->ProcessTouchEventPreDispatch(&event, &consumer);
+  gesture_recognizer()->CancelActiveTouches(&consumer);
+
   EXPECT_EQ(1, observer()->active_touches_cancelled_call_count());
   EXPECT_EQ(&consumer, observer()->last_cancelled());
 }

ui/events/gestures/gesture_recognizer_observer.h

@@ -13,12 +13,21 @@ namespace ui {
 
 class EVENTS_EXPORT GestureRecognizerObserver : public base::CheckedObserver {
  public:
+  // Called when CancelActiveTouchesExcept() is called.
   virtual void OnActiveTouchesCanceledExcept(
       GestureConsumer* not_cancelled) = 0;
+
+  // Called when TransferEventsTo() happened from |current_consumer| to
+  // |new_consumer|.
   virtual void OnEventsTransferred(
       GestureConsumer* current_consumer,
       GestureConsumer* new_consumer,
       TransferTouchesBehavior transfer_touches_behavior) = 0;
+
+  // Called when CancelActiveTouches() cancels touches on |consumer|. This is
+  // not called from CancelActiveTouchesExcept() causes cancel on |consumer|.
+  // Also this is not called when an invocation of CancelActiveTouches() doesn't
+  // cancel anything actually.
   virtual void OnActiveTouchesCanceled(GestureConsumer* consumer) = 0;
 
  protected: