Two Finger Tap

ui/chromeos/touch_exploration_controller_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.
 
 #include "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
@@ skipping 63 matching lines @@
 
 class MockTouchExplorationControllerDelegate
     : public ui::TouchExplorationControllerDelegate {
  public:
   virtual void PlayVolumeAdjustSound() OVERRIDE {
     ++num_times_adjust_sound_played_;
   }
   virtual void SetOutputLevel(int volume) OVERRIDE {
     volume_changes_.push_back(volume);
   }
+  virtual void SilenceSpokenFeedback() OVERRIDE {
+  }
 
   const std::vector<float> VolumeChanges() { return volume_changes_; }
   const size_t NumAdjustSounds() { return num_times_adjust_sound_played_; }
 
  private:
   std::vector<float> volume_changes_;
   size_t num_times_adjust_sound_played_ = 0;
 };
 
 }  // namespace
@@ skipping 26 matching lines @@
   bool IsInGestureInProgressStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->GESTURE_IN_PROGRESS;
   }
 
   bool IsInSlideGestureStateForTesting() const {
     return touch_exploration_controller_->state_ ==
            touch_exploration_controller_->SLIDE_GESTURE;
   }
 
+  bool IsInTwoFingerTapStateForTesting() const {
+    return touch_exploration_controller_->state_ ==
+           touch_exploration_controller_->TWO_FINGER_TAP;
+  }
+
   gfx::Rect BoundsOfRootWindowInDIPForTesting() const {
     return touch_exploration_controller_->root_window_->GetBoundsInScreen();
   }
 
   // VLOGs should be suppressed in tests that generate a lot of logs,
   // for example permutations of nine touch events.
   void SuppressVLOGsForTesting(bool suppress) {
     touch_exploration_controller_->VLOG_on_ = !suppress;
   }
 
@@ skipping 140 matching lines @@
 
   bool IsInGestureInProgressState() {
     return touch_exploration_controller_
         ->IsInGestureInProgressStateForTesting();
   }
 
   bool IsInSlideGestureState() {
     return touch_exploration_controller_->IsInSlideGestureStateForTesting();
   }
 
+  bool IsInTwoFingerTapState() {
+    return touch_exploration_controller_->IsInTwoFingerTapStateForTesting();
+  }
+
   gfx::Rect BoundsOfRootWindowInDIP() {
     return touch_exploration_controller_->BoundsOfRootWindowInDIPForTesting();
   }
 
   float GetMaxDistanceFromEdge() const{
     return touch_exploration_controller_->GetMaxDistanceFromEdge();
   }
 
   float GetSlopDistanceFromEdge() const{
     return touch_exploration_controller_->GetSlopDistanceFromEdge();
@@ skipping 1220 matching lines @@
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInSlideGestureState());
   EXPECT_FALSE(IsInTouchToMouseMode());
 
   AdvanceSimulatedTimePastTapDelay();
   EXPECT_FALSE(IsInGestureInProgressState());
   EXPECT_FALSE(IsInSlideGestureState());
   EXPECT_TRUE(IsInTouchToMouseMode());
 }
 
+TEST_F(TouchExplorationTest, TwoFingerTap) {

[James Cook, 2014/08/08 18:06:31]

Comment above what you are testing and why.

[lisayin, 2014/08/08 19:06:15]

Done.

+  SwitchTouchExplorationMode(true);
+
+  generator_->PressTouchId(1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  generator_->PressTouchId(2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->ReleaseTouchId(1);
+  generator_->ReleaseTouchId(2);
+
+  // Two key events should have been sent to silence the feedback.
+  ASSERT_EQ(2U, captured_events.size());

[James Cook, 2014/08/08 18:06:30]

Probably EXPECT_EQ is better -- the test should fail, not crash, if this isn't
true.

[lisayin, 2014/08/08 19:06:15]

Done.

+}
+
+TEST_F(TouchExplorationTest, TwoFingerTapWithDelay) {

[James Cook, 2014/08/08 18:06:31]

Comment please.

[lisayin, 2014/08/08 19:06:15]

Removed the timing check for two finger tap, so this test is obsolete.

+  SwitchTouchExplorationMode(true);
+
+  generator_->PressTouchId(1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  // If the second finger is placed before the delay, then a two finger tap is
+  // still sent.
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(10));
+
+  generator_->PressTouchId(2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->ReleaseTouchId(1);
+  generator_->ReleaseTouchId(2);
+
+  // Two key events should have been sent to silence the feedback.
+  ASSERT_EQ(2U, captured_events.size());

[James Cook, 2014/08/08 18:06:31]

EXPECT_EQ I think

+  ClearCapturedEvents();
+
+  generator_->PressTouchId(1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  // If the second finger is placed after the delay, then a two finger tap is
+  // not made.
+  simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(100));

[James Cook, 2014/08/08 18:06:31]

I would use a much larger delay (like 1000) just in case the original delay is
adjusted slightly.

+
+  generator_->PressTouchId(2);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  ASSERT_EQ(0U, captured_events.size());

[James Cook, 2014/08/08 18:06:31]

EXPECT_EQ ?

+}
+
+TEST_F(TouchExplorationTest, TwoFingerTapAndHold) {

[James Cook, 2014/08/08 18:06:30]

Comment please

[lisayin, 2014/08/08 19:06:15]

Done.

+  SwitchTouchExplorationMode(true);
+
+  generator_->PressTouchId(1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  generator_->PressTouchId(2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  AdvanceSimulatedTimePastTapDelay();
+  // Since the tap delay has elapsed, it should no longer be in two finger tap.
+  EXPECT_FALSE(IsInTwoFingerTapState());
+}
+
+TEST_F(TouchExplorationTest, TwoFingerTapAndMoveFirstFinger) {

[James Cook, 2014/08/08 18:06:31]

ditto

[lisayin, 2014/08/08 19:06:15]

Done.

+  SwitchTouchExplorationMode(true);
+
+  // Once one of the fingers leaves slop, it should no longer be in two finger
+  // tap.
+  ui::TouchEvent first_press_id_1(
+      ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 1, Now());

[James Cook, 2014/08/08 18:06:31]

I like how you use 100 vs. 200 for x vs. y -- much clearer than 100 for both.

[lisayin, 2014/08/08 19:06:15]

Acknowledged.

+  ui::TouchEvent first_press_id_2(
+      ui::ET_TOUCH_PRESSED, gfx::Point(110, 200), 2, Now());
+
+  ui::TouchEvent slop_move_id_1(
+      ui::ET_TOUCH_MOVED,
+      gfx::Point(100 + gesture_detector_config_.touch_slop, 200),
+      1,
+      Now());
+  ui::TouchEvent slop_move_id_2(
+      ui::ET_TOUCH_MOVED,
+      gfx::Point(110 + gesture_detector_config_.touch_slop, 200),
+      2,
+      Now());
+
+  ui::TouchEvent out_slop_id_1(
+      ui::ET_TOUCH_MOVED,
+      gfx::Point(100 + gesture_detector_config_.touch_slop + 1, 200),
+      1,
+      Now());
+
+  generator_->Dispatch(&first_press_id_1);

[James Cook, 2014/08/08 18:06:31]

Comment each of these little sections of code with what you are testing.

[lisayin, 2014/08/08 19:06:16]

Done.

+  EXPECT_FALSE(IsInTwoFingerTapState());
+  generator_->Dispatch(&first_press_id_2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->Dispatch(&slop_move_id_1);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+  generator_->Dispatch(&slop_move_id_2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  generator_->Dispatch(&out_slop_id_1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+}
+
+TEST_F(TouchExplorationTest, TwoFingerTapAndMoveSecondFinger) {

[James Cook, 2014/08/08 18:06:30]

comment

[lisayin, 2014/08/08 19:06:15]

Done.

+  SwitchTouchExplorationMode(true);
+
+  // Once one of the fingers leaves slop, it should no longer be in two finger
+  // tap.
+  ui::TouchEvent first_press_id_1(
+      ui::ET_TOUCH_PRESSED, gfx::Point(100, 200), 1, Now());
+  ui::TouchEvent first_press_id_2(
+      ui::ET_TOUCH_PRESSED, gfx::Point(110, 200), 2, Now());
+
+  ui::TouchEvent out_slop_id_2(
+      ui::ET_TOUCH_MOVED,
+      gfx::Point(100 + gesture_detector_config_.touch_slop + 1, 200),
+      1,
+      Now());
+
+  generator_->Dispatch(&first_press_id_1);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+
+  generator_->Dispatch(&first_press_id_2);
+  EXPECT_TRUE(IsInTwoFingerTapState());
+
+  const ScopedVector<ui::Event>& captured_events = GetCapturedEvents();
+  ASSERT_EQ(0U, captured_events.size());
+
+  generator_->Dispatch(&out_slop_id_2);
+  EXPECT_FALSE(IsInTwoFingerTapState());
+}
+
 }  // namespace ui